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   syms = NULL;
3274   codesecsym = 0;
3275   codesecsymend = 0;
3276   secsymend = 0;
3277   opdsymend = 0;
3278   symcount = 0;
3279   if (opd != NULL)
3280     {
3281       symcount = static_count;
3282       if (!relocatable)
3283         symcount += dyn_count;
3284       if (symcount == 0)
3285         return 0;
3286
3287       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3288       if (syms == NULL)
3289         return -1;
3290
3291       if (!relocatable && static_count != 0 && dyn_count != 0)
3292         {
3293           /* Use both symbol tables.  */
3294           memcpy (syms, static_syms, static_count * sizeof (*syms));
3295           memcpy (syms + static_count, dyn_syms,
3296                   (dyn_count + 1) * sizeof (*syms));
3297         }
3298       else if (!relocatable && static_count == 0)
3299         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3300       else
3301         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3302
3303       synthetic_relocatable = relocatable;
3304       synthetic_opd = opd;
3305       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3306
3307       if (!relocatable && symcount > 1)
3308         {
3309           long j;
3310           /* Trim duplicate syms, since we may have merged the normal and
3311              dynamic symbols.  Actually, we only care about syms that have
3312              different values, so trim any with the same value.  */
3313           for (i = 1, j = 1; i < symcount; ++i)
3314             if (syms[i - 1]->value + syms[i - 1]->section->vma
3315                 != syms[i]->value + syms[i]->section->vma)
3316               syms[j++] = syms[i];
3317           symcount = j;
3318         }
3319
3320       i = 0;
3321       /* Note that here and in compare_symbols we can't compare opd and
3322          sym->section directly.  With separate debug info files, the
3323          symbols will be extracted from the debug file while abfd passed
3324          to this function is the real binary.  */
3325       if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3326         ++i;
3327       codesecsym = i;
3328
3329       for (; i < symcount; ++i)
3330         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3331                                          | SEC_THREAD_LOCAL))
3332              != (SEC_CODE | SEC_ALLOC))
3333             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3334           break;
3335       codesecsymend = i;
3336
3337       for (; i < symcount; ++i)
3338         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3339           break;
3340       secsymend = i;
3341
3342       for (; i < symcount; ++i)
3343         if (strcmp (syms[i]->section->name, ".opd") != 0)
3344           break;
3345       opdsymend = i;
3346
3347       for (; i < symcount; ++i)
3348         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3349             != (SEC_CODE | SEC_ALLOC))
3350           break;
3351       symcount = i;
3352     }
3353   count = 0;
3354
3355   if (relocatable)
3356     {
3357       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3358       arelent *r;
3359       size_t size;
3360       long relcount;
3361
3362       if (opdsymend == secsymend)
3363         goto done;
3364
3365       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3366       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3367       if (relcount == 0)
3368         goto done;
3369
3370       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3371         {
3372           count = -1;
3373           goto done;
3374         }
3375
3376       size = 0;
3377       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3378         {
3379           asymbol *sym;
3380
3381           while (r < opd->relocation + relcount
3382                  && r->address < syms[i]->value + opd->vma)
3383             ++r;
3384
3385           if (r == opd->relocation + relcount)
3386             break;
3387
3388           if (r->address != syms[i]->value + opd->vma)
3389             continue;
3390
3391           if (r->howto->type != R_PPC64_ADDR64)
3392             continue;
3393
3394           sym = *r->sym_ptr_ptr;
3395           if (!sym_exists_at (syms, opdsymend, symcount,
3396                               sym->section->id, sym->value + r->addend))
3397             {
3398               ++count;
3399               size += sizeof (asymbol);
3400               size += strlen (syms[i]->name) + 2;
3401             }
3402         }
3403
3404       if (size == 0)
3405         goto done;
3406       s = *ret = bfd_malloc (size);
3407       if (s == NULL)
3408         {
3409           count = -1;
3410           goto done;
3411         }
3412
3413       names = (char *) (s + count);
3414
3415       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3416         {
3417           asymbol *sym;
3418
3419           while (r < opd->relocation + relcount
3420                  && r->address < syms[i]->value + opd->vma)
3421             ++r;
3422
3423           if (r == opd->relocation + relcount)
3424             break;
3425
3426           if (r->address != syms[i]->value + opd->vma)
3427             continue;
3428
3429           if (r->howto->type != R_PPC64_ADDR64)
3430             continue;
3431
3432           sym = *r->sym_ptr_ptr;
3433           if (!sym_exists_at (syms, opdsymend, symcount,
3434                               sym->section->id, sym->value + r->addend))
3435             {
3436               size_t len;
3437
3438               *s = *syms[i];
3439               s->flags |= BSF_SYNTHETIC;
3440               s->section = sym->section;
3441               s->value = sym->value + r->addend;
3442               s->name = names;
3443               *names++ = '.';
3444               len = strlen (syms[i]->name);
3445               memcpy (names, syms[i]->name, len + 1);
3446               names += len + 1;
3447               /* Have udata.p point back to the original symbol this
3448                  synthetic symbol was derived from.  */
3449               s->udata.p = syms[i];
3450               s++;
3451             }
3452         }
3453     }
3454   else
3455     {
3456       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3457       bfd_byte *contents = NULL;
3458       size_t size;
3459       long plt_count = 0;
3460       bfd_vma glink_vma = 0, resolv_vma = 0;
3461       asection *dynamic, *glink = NULL, *relplt = NULL;
3462       arelent *p;
3463
3464       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3465         {
3466         free_contents_and_exit_err:
3467           count = -1;
3468         free_contents_and_exit:
3469           if (contents)
3470             free (contents);
3471           goto done;
3472         }
3473
3474       size = 0;
3475       for (i = secsymend; i < opdsymend; ++i)
3476         {
3477           bfd_vma ent;
3478
3479           /* Ignore bogus symbols.  */
3480           if (syms[i]->value > opd->size - 8)
3481             continue;
3482
3483           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3484           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3485             {
3486               ++count;
3487               size += sizeof (asymbol);
3488               size += strlen (syms[i]->name) + 2;
3489             }
3490         }
3491
3492       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3493       if (dyn_count != 0
3494           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3495         {
3496           bfd_byte *dynbuf, *extdyn, *extdynend;
3497           size_t extdynsize;
3498           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3499
3500           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3501             goto free_contents_and_exit_err;
3502
3503           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3504           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3505
3506           extdyn = dynbuf;
3507           extdynend = extdyn + dynamic->size;
3508           for (; extdyn < extdynend; extdyn += extdynsize)
3509             {
3510               Elf_Internal_Dyn dyn;
3511               (*swap_dyn_in) (abfd, extdyn, &dyn);
3512
3513               if (dyn.d_tag == DT_NULL)
3514                 break;
3515
3516               if (dyn.d_tag == DT_PPC64_GLINK)
3517                 {
3518                   /* The first glink stub starts at offset 32; see
3519                      comment in ppc64_elf_finish_dynamic_sections. */
3520                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3521                   /* The .glink section usually does not survive the final
3522                      link; search for the section (usually .text) where the
3523                      glink stubs now reside.  */
3524                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3525                                                 &glink_vma);
3526                   break;
3527                 }
3528             }
3529
3530           free (dynbuf);
3531         }
3532
3533       if (glink != NULL)
3534         {
3535           /* Determine __glink trampoline by reading the relative branch
3536              from the first glink stub.  */
3537           bfd_byte buf[4];
3538           unsigned int off = 0;
3539
3540           while (bfd_get_section_contents (abfd, glink, buf,
3541                                            glink_vma + off - glink->vma, 4))
3542             {
3543               unsigned int insn = bfd_get_32 (abfd, buf);
3544               insn ^= B_DOT;
3545               if ((insn & ~0x3fffffc) == 0)
3546                 {
3547                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3548                   break;
3549                 }
3550               off += 4;
3551               if (off > 4)
3552                 break;
3553             }
3554
3555           if (resolv_vma)
3556             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3557
3558           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3559           if (relplt != NULL)
3560             {
3561               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3562               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3563                 goto free_contents_and_exit_err;
3564
3565               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3566               size += plt_count * sizeof (asymbol);
3567
3568               p = relplt->relocation;
3569               for (i = 0; i < plt_count; i++, p++)
3570                 {
3571                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3572                   if (p->addend != 0)
3573                     size += sizeof ("+0x") - 1 + 16;
3574                 }
3575             }
3576         }
3577
3578       if (size == 0)
3579         goto free_contents_and_exit;
3580       s = *ret = bfd_malloc (size);
3581       if (s == NULL)
3582         goto free_contents_and_exit_err;
3583
3584       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3585
3586       for (i = secsymend; i < opdsymend; ++i)
3587         {
3588           bfd_vma ent;
3589
3590           if (syms[i]->value > opd->size - 8)
3591             continue;
3592
3593           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3594           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3595             {
3596               long lo, hi;
3597               size_t len;
3598               asection *sec = abfd->sections;
3599
3600               *s = *syms[i];
3601               lo = codesecsym;
3602               hi = codesecsymend;
3603               while (lo < hi)
3604                 {
3605                   long mid = (lo + hi) >> 1;
3606                   if (syms[mid]->section->vma < ent)
3607                     lo = mid + 1;
3608                   else if (syms[mid]->section->vma > ent)
3609                     hi = mid;
3610                   else
3611                     {
3612                       sec = syms[mid]->section;
3613                       break;
3614                     }
3615                 }
3616
3617               if (lo >= hi && lo > codesecsym)
3618                 sec = syms[lo - 1]->section;
3619
3620               for (; sec != NULL; sec = sec->next)
3621                 {
3622                   if (sec->vma > ent)
3623                     break;
3624                   /* SEC_LOAD may not be set if SEC is from a separate debug
3625                      info file.  */
3626                   if ((sec->flags & SEC_ALLOC) == 0)
3627                     break;
3628                   if ((sec->flags & SEC_CODE) != 0)
3629                     s->section = sec;
3630                 }
3631               s->flags |= BSF_SYNTHETIC;
3632               s->value = ent - s->section->vma;
3633               s->name = names;
3634               *names++ = '.';
3635               len = strlen (syms[i]->name);
3636               memcpy (names, syms[i]->name, len + 1);
3637               names += len + 1;
3638               /* Have udata.p point back to the original symbol this
3639                  synthetic symbol was derived from.  */
3640               s->udata.p = syms[i];
3641               s++;
3642             }
3643         }
3644       free (contents);
3645
3646       if (glink != NULL && relplt != NULL)
3647         {
3648           if (resolv_vma)
3649             {
3650               /* Add a symbol for the main glink trampoline.  */
3651               memset (s, 0, sizeof *s);
3652               s->the_bfd = abfd;
3653               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3654               s->section = glink;
3655               s->value = resolv_vma - glink->vma;
3656               s->name = names;
3657               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3658               names += sizeof ("__glink_PLTresolve");
3659               s++;
3660               count++;
3661             }
3662
3663           /* FIXME: It would be very much nicer to put sym@plt on the
3664              stub rather than on the glink branch table entry.  The
3665              objdump disassembler would then use a sensible symbol
3666              name on plt calls.  The difficulty in doing so is
3667              a) finding the stubs, and,
3668              b) matching stubs against plt entries, and,
3669              c) there can be multiple stubs for a given plt entry.
3670
3671              Solving (a) could be done by code scanning, but older
3672              ppc64 binaries used different stubs to current code.
3673              (b) is the tricky one since you need to known the toc
3674              pointer for at least one function that uses a pic stub to
3675              be able to calculate the plt address referenced.
3676              (c) means gdb would need to set multiple breakpoints (or
3677              find the glink branch itself) when setting breakpoints
3678              for pending shared library loads.  */
3679           p = relplt->relocation;
3680           for (i = 0; i < plt_count; i++, p++)
3681             {
3682               size_t len;
3683
3684               *s = **p->sym_ptr_ptr;
3685               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3686                  we are defining a symbol, ensure one of them is set.  */
3687               if ((s->flags & BSF_LOCAL) == 0)
3688                 s->flags |= BSF_GLOBAL;
3689               s->flags |= BSF_SYNTHETIC;
3690               s->section = glink;
3691               s->value = glink_vma - glink->vma;
3692               s->name = names;
3693               s->udata.p = NULL;
3694               len = strlen ((*p->sym_ptr_ptr)->name);
3695               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3696               names += len;
3697               if (p->addend != 0)
3698                 {
3699                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3700                   names += sizeof ("+0x") - 1;
3701                   bfd_sprintf_vma (abfd, names, p->addend);
3702                   names += strlen (names);
3703                 }
3704               memcpy (names, "@plt", sizeof ("@plt"));
3705               names += sizeof ("@plt");
3706               s++;
3707               if (abi < 2)
3708                 {
3709                   glink_vma += 8;
3710                   if (i >= 0x8000)
3711                     glink_vma += 4;
3712                 }
3713               else
3714                 glink_vma += 4;
3715             }
3716           count += plt_count;
3717         }
3718     }
3719
3720  done:
3721   free (syms);
3722   return count;
3723 }
3724 \f
3725 /* The following functions are specific to the ELF linker, while
3726    functions above are used generally.  Those named ppc64_elf_* are
3727    called by the main ELF linker code.  They appear in this file more
3728    or less in the order in which they are called.  eg.
3729    ppc64_elf_check_relocs is called early in the link process,
3730    ppc64_elf_finish_dynamic_sections is one of the last functions
3731    called.
3732
3733    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3734    functions have both a function code symbol and a function descriptor
3735    symbol.  A call to foo in a relocatable object file looks like:
3736
3737    .            .text
3738    .    x:
3739    .            bl      .foo
3740    .            nop
3741
3742    The function definition in another object file might be:
3743
3744    .            .section .opd
3745    .    foo:    .quad   .foo
3746    .            .quad   .TOC.@tocbase
3747    .            .quad   0
3748    .
3749    .            .text
3750    .    .foo:   blr
3751
3752    When the linker resolves the call during a static link, the branch
3753    unsurprisingly just goes to .foo and the .opd information is unused.
3754    If the function definition is in a shared library, things are a little
3755    different:  The call goes via a plt call stub, the opd information gets
3756    copied to the plt, and the linker patches the nop.
3757
3758    .    x:
3759    .            bl      .foo_stub
3760    .            ld      2,40(1)
3761    .
3762    .
3763    .    .foo_stub:
3764    .            std     2,40(1)                 # in practice, the call stub
3765    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3766    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3767    .            ld      12,0(11)
3768    .            ld      2,8(11)
3769    .            mtctr   12
3770    .            ld      11,16(11)
3771    .            bctr
3772    .
3773    .            .section .plt
3774    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3775
3776    The "reloc ()" notation is supposed to indicate that the linker emits
3777    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3778    copying.
3779
3780    What are the difficulties here?  Well, firstly, the relocations
3781    examined by the linker in check_relocs are against the function code
3782    sym .foo, while the dynamic relocation in the plt is emitted against
3783    the function descriptor symbol, foo.  Somewhere along the line, we need
3784    to carefully copy dynamic link information from one symbol to the other.
3785    Secondly, the generic part of the elf linker will make .foo a dynamic
3786    symbol as is normal for most other backends.  We need foo dynamic
3787    instead, at least for an application final link.  However, when
3788    creating a shared library containing foo, we need to have both symbols
3789    dynamic so that references to .foo are satisfied during the early
3790    stages of linking.  Otherwise the linker might decide to pull in a
3791    definition from some other object, eg. a static library.
3792
3793    Update: As of August 2004, we support a new convention.  Function
3794    calls may use the function descriptor symbol, ie. "bl foo".  This
3795    behaves exactly as "bl .foo".  */
3796
3797 /* Of those relocs that might be copied as dynamic relocs, this
3798    function selects those that must be copied when linking a shared
3799    library or PIE, even when the symbol is local.  */
3800
3801 static int
3802 must_be_dyn_reloc (struct bfd_link_info *info,
3803                    enum elf_ppc64_reloc_type r_type)
3804 {
3805   switch (r_type)
3806     {
3807     default:
3808       /* Only relative relocs can be resolved when the object load
3809          address isn't fixed.  DTPREL64 is excluded because the
3810          dynamic linker needs to differentiate global dynamic from
3811          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3812       return 1;
3813
3814     case R_PPC64_REL32:
3815     case R_PPC64_REL64:
3816     case R_PPC64_REL30:
3817       return 0;
3818
3819     case R_PPC64_TPREL16:
3820     case R_PPC64_TPREL16_LO:
3821     case R_PPC64_TPREL16_HI:
3822     case R_PPC64_TPREL16_HA:
3823     case R_PPC64_TPREL16_DS:
3824     case R_PPC64_TPREL16_LO_DS:
3825     case R_PPC64_TPREL16_HIGH:
3826     case R_PPC64_TPREL16_HIGHA:
3827     case R_PPC64_TPREL16_HIGHER:
3828     case R_PPC64_TPREL16_HIGHERA:
3829     case R_PPC64_TPREL16_HIGHEST:
3830     case R_PPC64_TPREL16_HIGHESTA:
3831     case R_PPC64_TPREL64:
3832       /* These relocations are relative but in a shared library the
3833          linker doesn't know the thread pointer base.  */
3834       return bfd_link_dll (info);
3835     }
3836 }
3837
3838 /* Whether an undefined weak symbol should resolve to its link-time
3839    value, even in PIC or PIE objects.  */
3840 #define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H)             \
3841   ((H)->root.type == bfd_link_hash_undefweak            \
3842    && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT    \
3843        || (INFO)->dynamic_undefined_weak == 0))
3844
3845 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3846    copying dynamic variables from a shared lib into an app's dynbss
3847    section, and instead use a dynamic relocation to point into the
3848    shared lib.  With code that gcc generates, it's vital that this be
3849    enabled;  In the PowerPC64 ABI, the address of a function is actually
3850    the address of a function descriptor, which resides in the .opd
3851    section.  gcc uses the descriptor directly rather than going via the
3852    GOT as some other ABI's do, which means that initialized function
3853    pointers must reference the descriptor.  Thus, a function pointer
3854    initialized to the address of a function in a shared library will
3855    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3856    redefines the function descriptor symbol to point to the copy.  This
3857    presents a problem as a plt entry for that function is also
3858    initialized from the function descriptor symbol and the copy reloc
3859    may not be initialized first.  */
3860 #define ELIMINATE_COPY_RELOCS 1
3861
3862 /* Section name for stubs is the associated section name plus this
3863    string.  */
3864 #define STUB_SUFFIX ".stub"
3865
3866 /* Linker stubs.
3867    ppc_stub_long_branch:
3868    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3869    destination, but a 24 bit branch in a stub section will reach.
3870    .    b       dest
3871
3872    ppc_stub_plt_branch:
3873    Similar to the above, but a 24 bit branch in the stub section won't
3874    reach its destination.
3875    .    addis   %r11,%r2,xxx@toc@ha
3876    .    ld      %r12,xxx@toc@l(%r11)
3877    .    mtctr   %r12
3878    .    bctr
3879
3880    ppc_stub_plt_call:
3881    Used to call a function in a shared library.  If it so happens that
3882    the plt entry referenced crosses a 64k boundary, then an extra
3883    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3884    .    std     %r2,40(%r1)
3885    .    addis   %r11,%r2,xxx@toc@ha
3886    .    ld      %r12,xxx+0@toc@l(%r11)
3887    .    mtctr   %r12
3888    .    ld      %r2,xxx+8@toc@l(%r11)
3889    .    ld      %r11,xxx+16@toc@l(%r11)
3890    .    bctr
3891
3892    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3893    code to adjust the value and save r2 to support multiple toc sections.
3894    A ppc_stub_long_branch with an r2 offset looks like:
3895    .    std     %r2,40(%r1)
3896    .    addis   %r2,%r2,off@ha
3897    .    addi    %r2,%r2,off@l
3898    .    b       dest
3899
3900    A ppc_stub_plt_branch with an r2 offset looks like:
3901    .    std     %r2,40(%r1)
3902    .    addis   %r11,%r2,xxx@toc@ha
3903    .    ld      %r12,xxx@toc@l(%r11)
3904    .    addis   %r2,%r2,off@ha
3905    .    addi    %r2,%r2,off@l
3906    .    mtctr   %r12
3907    .    bctr
3908
3909    In cases where the "addis" instruction would add zero, the "addis" is
3910    omitted and following instructions modified slightly in some cases.
3911 */
3912
3913 enum ppc_stub_type {
3914   ppc_stub_none,
3915   ppc_stub_long_branch,
3916   ppc_stub_long_branch_r2off,
3917   ppc_stub_plt_branch,
3918   ppc_stub_plt_branch_r2off,
3919   ppc_stub_plt_call,
3920   ppc_stub_plt_call_r2save,
3921   ppc_stub_global_entry,
3922   ppc_stub_save_res
3923 };
3924
3925 /* Information on stub grouping.  */
3926 struct map_stub
3927 {
3928   /* The stub section.  */
3929   asection *stub_sec;
3930   /* This is the section to which stubs in the group will be attached.  */
3931   asection *link_sec;
3932   /* Next group.  */
3933   struct map_stub *next;
3934   /* Whether to emit a copy of register save/restore functions in this
3935      group.  */
3936   int needs_save_res;
3937   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3938      or -1u if no such stub with bctrl exists.  */
3939   unsigned int tls_get_addr_opt_bctrl;
3940 };
3941
3942 struct ppc_stub_hash_entry {
3943
3944   /* Base hash table entry structure.  */
3945   struct bfd_hash_entry root;
3946
3947   enum ppc_stub_type stub_type;
3948
3949   /* Group information.  */
3950   struct map_stub *group;
3951
3952   /* Offset within stub_sec of the beginning of this stub.  */
3953   bfd_vma stub_offset;
3954
3955   /* Given the symbol's value and its section we can determine its final
3956      value when building the stubs (so the stub knows where to jump.  */
3957   bfd_vma target_value;
3958   asection *target_section;
3959
3960   /* The symbol table entry, if any, that this was derived from.  */
3961   struct ppc_link_hash_entry *h;
3962   struct plt_entry *plt_ent;
3963
3964   /* Symbol st_other.  */
3965   unsigned char other;
3966 };
3967
3968 struct ppc_branch_hash_entry {
3969
3970   /* Base hash table entry structure.  */
3971   struct bfd_hash_entry root;
3972
3973   /* Offset within branch lookup table.  */
3974   unsigned int offset;
3975
3976   /* Generation marker.  */
3977   unsigned int iter;
3978 };
3979
3980 /* Used to track dynamic relocations for local symbols.  */
3981 struct ppc_dyn_relocs
3982 {
3983   struct ppc_dyn_relocs *next;
3984
3985   /* The input section of the reloc.  */
3986   asection *sec;
3987
3988   /* Total number of relocs copied for the input section.  */
3989   unsigned int count : 31;
3990
3991   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3992   unsigned int ifunc : 1;
3993 };
3994
3995 struct ppc_link_hash_entry
3996 {
3997   struct elf_link_hash_entry elf;
3998
3999   union {
4000     /* A pointer to the most recently used stub hash entry against this
4001        symbol.  */
4002     struct ppc_stub_hash_entry *stub_cache;
4003
4004     /* A pointer to the next symbol starting with a '.'  */
4005     struct ppc_link_hash_entry *next_dot_sym;
4006   } u;
4007
4008   /* Track dynamic relocs copied for this symbol.  */
4009   struct elf_dyn_relocs *dyn_relocs;
4010
4011   /* Chain of aliases referring to a weakdef.  */
4012   struct ppc_link_hash_entry *weakref;
4013
4014   /* Link between function code and descriptor symbols.  */
4015   struct ppc_link_hash_entry *oh;
4016
4017   /* Flag function code and descriptor symbols.  */
4018   unsigned int is_func:1;
4019   unsigned int is_func_descriptor:1;
4020   unsigned int fake:1;
4021
4022   /* Whether global opd/toc sym has been adjusted or not.
4023      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4024      should be set for all globals defined in any opd/toc section.  */
4025   unsigned int adjust_done:1;
4026
4027   /* Set if this is an out-of-line register save/restore function,
4028      with non-standard calling convention.  */
4029   unsigned int save_res:1;
4030
4031   /* Set if a duplicate symbol with non-zero localentry is detected,
4032      even when the duplicate symbol does not provide a definition.  */
4033   unsigned int non_zero_localentry:1;
4034
4035   /* Contexts in which symbol is used in the GOT (or TOC).
4036      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4037      corresponding relocs are encountered during check_relocs.
4038      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4039      indicate the corresponding GOT entry type is not needed.
4040      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4041      a TPREL one.  We use a separate flag rather than setting TPREL
4042      just for convenience in distinguishing the two cases.  */
4043 #define TLS_GD           1      /* GD reloc. */
4044 #define TLS_LD           2      /* LD reloc. */
4045 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4046 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4047 #define TLS_TLS         16      /* Any TLS reloc.  */
4048 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4049 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4050 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4051   unsigned char tls_mask;
4052 };
4053
4054 /* ppc64 ELF linker hash table.  */
4055
4056 struct ppc_link_hash_table
4057 {
4058   struct elf_link_hash_table elf;
4059
4060   /* The stub hash table.  */
4061   struct bfd_hash_table stub_hash_table;
4062
4063   /* Another hash table for plt_branch stubs.  */
4064   struct bfd_hash_table branch_hash_table;
4065
4066   /* Hash table for function prologue tocsave.  */
4067   htab_t tocsave_htab;
4068
4069   /* Various options and other info passed from the linker.  */
4070   struct ppc64_elf_params *params;
4071
4072   /* The size of sec_info below.  */
4073   unsigned int sec_info_arr_size;
4074
4075   /* Per-section array of extra section info.  Done this way rather
4076      than as part of ppc64_elf_section_data so we have the info for
4077      non-ppc64 sections.  */
4078   struct
4079   {
4080     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4081     bfd_vma toc_off;
4082
4083     union
4084     {
4085       /* The section group that this section belongs to.  */
4086       struct map_stub *group;
4087       /* A temp section list pointer.  */
4088       asection *list;
4089     } u;
4090   } *sec_info;
4091
4092   /* Linked list of groups.  */
4093   struct map_stub *group;
4094
4095   /* Temp used when calculating TOC pointers.  */
4096   bfd_vma toc_curr;
4097   bfd *toc_bfd;
4098   asection *toc_first_sec;
4099
4100   /* Used when adding symbols.  */
4101   struct ppc_link_hash_entry *dot_syms;
4102
4103   /* Shortcuts to get to dynamic linker sections.  */
4104   asection *glink;
4105   asection *sfpr;
4106   asection *brlt;
4107   asection *relbrlt;
4108   asection *glink_eh_frame;
4109
4110   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4111   struct ppc_link_hash_entry *tls_get_addr;
4112   struct ppc_link_hash_entry *tls_get_addr_fd;
4113
4114   /* The size of reliplt used by got entry relocs.  */
4115   bfd_size_type got_reli_size;
4116
4117   /* Statistics.  */
4118   unsigned long stub_count[ppc_stub_global_entry];
4119
4120   /* Number of stubs against global syms.  */
4121   unsigned long stub_globals;
4122
4123   /* Set if we're linking code with function descriptors.  */
4124   unsigned int opd_abi:1;
4125
4126   /* Support for multiple toc sections.  */
4127   unsigned int do_multi_toc:1;
4128   unsigned int multi_toc_needed:1;
4129   unsigned int second_toc_pass:1;
4130   unsigned int do_toc_opt:1;
4131
4132   /* Set if tls optimization is enabled.  */
4133   unsigned int do_tls_opt:1;
4134
4135   /* Set on error.  */
4136   unsigned int stub_error:1;
4137
4138   /* Whether func_desc_adjust needs to be run over symbols.  */
4139   unsigned int need_func_desc_adj:1;
4140
4141   /* Whether there exist local gnu indirect function resolvers,
4142      referenced by dynamic relocations.  */
4143   unsigned int local_ifunc_resolver:1;
4144   unsigned int maybe_local_ifunc_resolver:1;
4145
4146   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4147   unsigned int has_plt_localentry0:1;
4148
4149   /* Incremented every time we size stubs.  */
4150   unsigned int stub_iteration;
4151
4152   /* Small local sym cache.  */
4153   struct sym_cache sym_cache;
4154 };
4155
4156 /* Rename some of the generic section flags to better document how they
4157    are used here.  */
4158
4159 /* Nonzero if this section has TLS related relocations.  */
4160 #define has_tls_reloc sec_flg0
4161
4162 /* Nonzero if this section has a call to __tls_get_addr.  */
4163 #define has_tls_get_addr_call sec_flg1
4164
4165 /* Nonzero if this section has any toc or got relocs.  */
4166 #define has_toc_reloc sec_flg2
4167
4168 /* Nonzero if this section has a call to another section that uses
4169    the toc or got.  */
4170 #define makes_toc_func_call sec_flg3
4171
4172 /* Recursion protection when determining above flag.  */
4173 #define call_check_in_progress sec_flg4
4174 #define call_check_done sec_flg5
4175
4176 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4177
4178 #define ppc_hash_table(p) \
4179   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4180   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4181
4182 #define ppc_stub_hash_lookup(table, string, create, copy) \
4183   ((struct ppc_stub_hash_entry *) \
4184    bfd_hash_lookup ((table), (string), (create), (copy)))
4185
4186 #define ppc_branch_hash_lookup(table, string, create, copy) \
4187   ((struct ppc_branch_hash_entry *) \
4188    bfd_hash_lookup ((table), (string), (create), (copy)))
4189
4190 /* Create an entry in the stub hash table.  */
4191
4192 static struct bfd_hash_entry *
4193 stub_hash_newfunc (struct bfd_hash_entry *entry,
4194                    struct bfd_hash_table *table,
4195                    const char *string)
4196 {
4197   /* Allocate the structure if it has not already been allocated by a
4198      subclass.  */
4199   if (entry == NULL)
4200     {
4201       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4202       if (entry == NULL)
4203         return entry;
4204     }
4205
4206   /* Call the allocation method of the superclass.  */
4207   entry = bfd_hash_newfunc (entry, table, string);
4208   if (entry != NULL)
4209     {
4210       struct ppc_stub_hash_entry *eh;
4211
4212       /* Initialize the local fields.  */
4213       eh = (struct ppc_stub_hash_entry *) entry;
4214       eh->stub_type = ppc_stub_none;
4215       eh->group = NULL;
4216       eh->stub_offset = 0;
4217       eh->target_value = 0;
4218       eh->target_section = NULL;
4219       eh->h = NULL;
4220       eh->plt_ent = NULL;
4221       eh->other = 0;
4222     }
4223
4224   return entry;
4225 }
4226
4227 /* Create an entry in the branch hash table.  */
4228
4229 static struct bfd_hash_entry *
4230 branch_hash_newfunc (struct bfd_hash_entry *entry,
4231                      struct bfd_hash_table *table,
4232                      const char *string)
4233 {
4234   /* Allocate the structure if it has not already been allocated by a
4235      subclass.  */
4236   if (entry == NULL)
4237     {
4238       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4239       if (entry == NULL)
4240         return entry;
4241     }
4242
4243   /* Call the allocation method of the superclass.  */
4244   entry = bfd_hash_newfunc (entry, table, string);
4245   if (entry != NULL)
4246     {
4247       struct ppc_branch_hash_entry *eh;
4248
4249       /* Initialize the local fields.  */
4250       eh = (struct ppc_branch_hash_entry *) entry;
4251       eh->offset = 0;
4252       eh->iter = 0;
4253     }
4254
4255   return entry;
4256 }
4257
4258 /* Create an entry in a ppc64 ELF linker hash table.  */
4259
4260 static struct bfd_hash_entry *
4261 link_hash_newfunc (struct bfd_hash_entry *entry,
4262                    struct bfd_hash_table *table,
4263                    const char *string)
4264 {
4265   /* Allocate the structure if it has not already been allocated by a
4266      subclass.  */
4267   if (entry == NULL)
4268     {
4269       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4270       if (entry == NULL)
4271         return entry;
4272     }
4273
4274   /* Call the allocation method of the superclass.  */
4275   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4276   if (entry != NULL)
4277     {
4278       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4279
4280       memset (&eh->u.stub_cache, 0,
4281               (sizeof (struct ppc_link_hash_entry)
4282                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4283
4284       /* When making function calls, old ABI code references function entry
4285          points (dot symbols), while new ABI code references the function
4286          descriptor symbol.  We need to make any combination of reference and
4287          definition work together, without breaking archive linking.
4288
4289          For a defined function "foo" and an undefined call to "bar":
4290          An old object defines "foo" and ".foo", references ".bar" (possibly
4291          "bar" too).
4292          A new object defines "foo" and references "bar".
4293
4294          A new object thus has no problem with its undefined symbols being
4295          satisfied by definitions in an old object.  On the other hand, the
4296          old object won't have ".bar" satisfied by a new object.
4297
4298          Keep a list of newly added dot-symbols.  */
4299
4300       if (string[0] == '.')
4301         {
4302           struct ppc_link_hash_table *htab;
4303
4304           htab = (struct ppc_link_hash_table *) table;
4305           eh->u.next_dot_sym = htab->dot_syms;
4306           htab->dot_syms = eh;
4307         }
4308     }
4309
4310   return entry;
4311 }
4312
4313 struct tocsave_entry {
4314   asection *sec;
4315   bfd_vma offset;
4316 };
4317
4318 static hashval_t
4319 tocsave_htab_hash (const void *p)
4320 {
4321   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4322   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4323 }
4324
4325 static int
4326 tocsave_htab_eq (const void *p1, const void *p2)
4327 {
4328   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4329   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4330   return e1->sec == e2->sec && e1->offset == e2->offset;
4331 }
4332
4333 /* Destroy a ppc64 ELF linker hash table.  */
4334
4335 static void
4336 ppc64_elf_link_hash_table_free (bfd *obfd)
4337 {
4338   struct ppc_link_hash_table *htab;
4339
4340   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4341   if (htab->tocsave_htab)
4342     htab_delete (htab->tocsave_htab);
4343   bfd_hash_table_free (&htab->branch_hash_table);
4344   bfd_hash_table_free (&htab->stub_hash_table);
4345   _bfd_elf_link_hash_table_free (obfd);
4346 }
4347
4348 /* Create a ppc64 ELF linker hash table.  */
4349
4350 static struct bfd_link_hash_table *
4351 ppc64_elf_link_hash_table_create (bfd *abfd)
4352 {
4353   struct ppc_link_hash_table *htab;
4354   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4355
4356   htab = bfd_zmalloc (amt);
4357   if (htab == NULL)
4358     return NULL;
4359
4360   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4361                                       sizeof (struct ppc_link_hash_entry),
4362                                       PPC64_ELF_DATA))
4363     {
4364       free (htab);
4365       return NULL;
4366     }
4367
4368   /* Init the stub hash table too.  */
4369   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4370                             sizeof (struct ppc_stub_hash_entry)))
4371     {
4372       _bfd_elf_link_hash_table_free (abfd);
4373       return NULL;
4374     }
4375
4376   /* And the branch hash table.  */
4377   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4378                             sizeof (struct ppc_branch_hash_entry)))
4379     {
4380       bfd_hash_table_free (&htab->stub_hash_table);
4381       _bfd_elf_link_hash_table_free (abfd);
4382       return NULL;
4383     }
4384
4385   htab->tocsave_htab = htab_try_create (1024,
4386                                         tocsave_htab_hash,
4387                                         tocsave_htab_eq,
4388                                         NULL);
4389   if (htab->tocsave_htab == NULL)
4390     {
4391       ppc64_elf_link_hash_table_free (abfd);
4392       return NULL;
4393     }
4394   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4395
4396   /* Initializing two fields of the union is just cosmetic.  We really
4397      only care about glist, but when compiled on a 32-bit host the
4398      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4399      debugger inspection of these fields look nicer.  */
4400   htab->elf.init_got_refcount.refcount = 0;
4401   htab->elf.init_got_refcount.glist = NULL;
4402   htab->elf.init_plt_refcount.refcount = 0;
4403   htab->elf.init_plt_refcount.glist = NULL;
4404   htab->elf.init_got_offset.offset = 0;
4405   htab->elf.init_got_offset.glist = NULL;
4406   htab->elf.init_plt_offset.offset = 0;
4407   htab->elf.init_plt_offset.glist = NULL;
4408
4409   return &htab->elf.root;
4410 }
4411
4412 /* Create sections for linker generated code.  */
4413
4414 static bfd_boolean
4415 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4416 {
4417   struct ppc_link_hash_table *htab;
4418   flagword flags;
4419
4420   htab = ppc_hash_table (info);
4421
4422   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4423            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4424   if (htab->params->save_restore_funcs)
4425     {
4426       /* Create .sfpr for code to save and restore fp regs.  */
4427       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4428                                                        flags);
4429       if (htab->sfpr == NULL
4430           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4431         return FALSE;
4432     }
4433
4434   if (bfd_link_relocatable (info))
4435     return TRUE;
4436
4437   /* Create .glink for lazy dynamic linking support.  */
4438   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4439                                                     flags);
4440   if (htab->glink == NULL
4441       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4442     return FALSE;
4443
4444   if (!info->no_ld_generated_unwind_info)
4445     {
4446       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4447                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4448       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4449                                                                  ".eh_frame",
4450                                                                  flags);
4451       if (htab->glink_eh_frame == NULL
4452           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4453         return FALSE;
4454     }
4455
4456   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4457   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4458   if (htab->elf.iplt == NULL
4459       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4460     return FALSE;
4461
4462   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4463            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4464   htab->elf.irelplt
4465     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4466   if (htab->elf.irelplt == NULL
4467       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4468     return FALSE;
4469
4470   /* Create branch lookup table for plt_branch stubs.  */
4471   flags = (SEC_ALLOC | SEC_LOAD
4472            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4473   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4474                                                    flags);
4475   if (htab->brlt == NULL
4476       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4477     return FALSE;
4478
4479   if (!bfd_link_pic (info))
4480     return TRUE;
4481
4482   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4483            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4484   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4485                                                       ".rela.branch_lt",
4486                                                       flags);
4487   if (htab->relbrlt == NULL
4488       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4489     return FALSE;
4490
4491   return TRUE;
4492 }
4493
4494 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4495
4496 bfd_boolean
4497 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4498                          struct ppc64_elf_params *params)
4499 {
4500   struct ppc_link_hash_table *htab;
4501
4502   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4503
4504 /* Always hook our dynamic sections into the first bfd, which is the
4505    linker created stub bfd.  This ensures that the GOT header is at
4506    the start of the output TOC section.  */
4507   htab = ppc_hash_table (info);
4508   htab->elf.dynobj = params->stub_bfd;
4509   htab->params = params;
4510
4511   return create_linkage_sections (htab->elf.dynobj, info);
4512 }
4513
4514 /* Build a name for an entry in the stub hash table.  */
4515
4516 static char *
4517 ppc_stub_name (const asection *input_section,
4518                const asection *sym_sec,
4519                const struct ppc_link_hash_entry *h,
4520                const Elf_Internal_Rela *rel)
4521 {
4522   char *stub_name;
4523   ssize_t len;
4524
4525   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4526      offsets from a sym as a branch target?  In fact, we could
4527      probably assume the addend is always zero.  */
4528   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4529
4530   if (h)
4531     {
4532       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4533       stub_name = bfd_malloc (len);
4534       if (stub_name == NULL)
4535         return stub_name;
4536
4537       len = sprintf (stub_name, "%08x.%s+%x",
4538                      input_section->id & 0xffffffff,
4539                      h->elf.root.root.string,
4540                      (int) rel->r_addend & 0xffffffff);
4541     }
4542   else
4543     {
4544       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4545       stub_name = bfd_malloc (len);
4546       if (stub_name == NULL)
4547         return stub_name;
4548
4549       len = sprintf (stub_name, "%08x.%x:%x+%x",
4550                      input_section->id & 0xffffffff,
4551                      sym_sec->id & 0xffffffff,
4552                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4553                      (int) rel->r_addend & 0xffffffff);
4554     }
4555   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4556     stub_name[len - 2] = 0;
4557   return stub_name;
4558 }
4559
4560 /* Look up an entry in the stub hash.  Stub entries are cached because
4561    creating the stub name takes a bit of time.  */
4562
4563 static struct ppc_stub_hash_entry *
4564 ppc_get_stub_entry (const asection *input_section,
4565                     const asection *sym_sec,
4566                     struct ppc_link_hash_entry *h,
4567                     const Elf_Internal_Rela *rel,
4568                     struct ppc_link_hash_table *htab)
4569 {
4570   struct ppc_stub_hash_entry *stub_entry;
4571   struct map_stub *group;
4572
4573   /* If this input section is part of a group of sections sharing one
4574      stub section, then use the id of the first section in the group.
4575      Stub names need to include a section id, as there may well be
4576      more than one stub used to reach say, printf, and we need to
4577      distinguish between them.  */
4578   group = htab->sec_info[input_section->id].u.group;
4579   if (group == NULL)
4580     return NULL;
4581
4582   if (h != NULL && h->u.stub_cache != NULL
4583       && h->u.stub_cache->h == h
4584       && h->u.stub_cache->group == group)
4585     {
4586       stub_entry = h->u.stub_cache;
4587     }
4588   else
4589     {
4590       char *stub_name;
4591
4592       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4593       if (stub_name == NULL)
4594         return NULL;
4595
4596       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4597                                          stub_name, FALSE, FALSE);
4598       if (h != NULL)
4599         h->u.stub_cache = stub_entry;
4600
4601       free (stub_name);
4602     }
4603
4604   return stub_entry;
4605 }
4606
4607 /* Add a new stub entry to the stub hash.  Not all fields of the new
4608    stub entry are initialised.  */
4609
4610 static struct ppc_stub_hash_entry *
4611 ppc_add_stub (const char *stub_name,
4612               asection *section,
4613               struct bfd_link_info *info)
4614 {
4615   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4616   struct map_stub *group;
4617   asection *link_sec;
4618   asection *stub_sec;
4619   struct ppc_stub_hash_entry *stub_entry;
4620
4621   group = htab->sec_info[section->id].u.group;
4622   link_sec = group->link_sec;
4623   stub_sec = group->stub_sec;
4624   if (stub_sec == NULL)
4625     {
4626       size_t namelen;
4627       bfd_size_type len;
4628       char *s_name;
4629
4630       namelen = strlen (link_sec->name);
4631       len = namelen + sizeof (STUB_SUFFIX);
4632       s_name = bfd_alloc (htab->params->stub_bfd, len);
4633       if (s_name == NULL)
4634         return NULL;
4635
4636       memcpy (s_name, link_sec->name, namelen);
4637       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4638       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4639       if (stub_sec == NULL)
4640         return NULL;
4641       group->stub_sec = stub_sec;
4642     }
4643
4644   /* Enter this entry into the linker stub hash table.  */
4645   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4646                                      TRUE, FALSE);
4647   if (stub_entry == NULL)
4648     {
4649       /* xgettext:c-format */
4650       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4651                               section->owner, stub_name);
4652       return NULL;
4653     }
4654
4655   stub_entry->group = group;
4656   stub_entry->stub_offset = 0;
4657   return stub_entry;
4658 }
4659
4660 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4661    not already done.  */
4662
4663 static bfd_boolean
4664 create_got_section (bfd *abfd, struct bfd_link_info *info)
4665 {
4666   asection *got, *relgot;
4667   flagword flags;
4668   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4669
4670   if (!is_ppc64_elf (abfd))
4671     return FALSE;
4672   if (htab == NULL)
4673     return FALSE;
4674
4675   if (!htab->elf.sgot
4676       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4677     return FALSE;
4678
4679   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4680            | SEC_LINKER_CREATED);
4681
4682   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4683   if (!got
4684       || !bfd_set_section_alignment (abfd, got, 3))
4685     return FALSE;
4686
4687   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4688                                                flags | SEC_READONLY);
4689   if (!relgot
4690       || ! bfd_set_section_alignment (abfd, relgot, 3))
4691     return FALSE;
4692
4693   ppc64_elf_tdata (abfd)->got = got;
4694   ppc64_elf_tdata (abfd)->relgot = relgot;
4695   return TRUE;
4696 }
4697
4698 /* Follow indirect and warning symbol links.  */
4699
4700 static inline struct bfd_link_hash_entry *
4701 follow_link (struct bfd_link_hash_entry *h)
4702 {
4703   while (h->type == bfd_link_hash_indirect
4704          || h->type == bfd_link_hash_warning)
4705     h = h->u.i.link;
4706   return h;
4707 }
4708
4709 static inline struct elf_link_hash_entry *
4710 elf_follow_link (struct elf_link_hash_entry *h)
4711 {
4712   return (struct elf_link_hash_entry *) follow_link (&h->root);
4713 }
4714
4715 static inline struct ppc_link_hash_entry *
4716 ppc_follow_link (struct ppc_link_hash_entry *h)
4717 {
4718   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4719 }
4720
4721 /* Merge PLT info on FROM with that on TO.  */
4722
4723 static void
4724 move_plt_plist (struct ppc_link_hash_entry *from,
4725                 struct ppc_link_hash_entry *to)
4726 {
4727   if (from->elf.plt.plist != NULL)
4728     {
4729       if (to->elf.plt.plist != NULL)
4730         {
4731           struct plt_entry **entp;
4732           struct plt_entry *ent;
4733
4734           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4735             {
4736               struct plt_entry *dent;
4737
4738               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4739                 if (dent->addend == ent->addend)
4740                   {
4741                     dent->plt.refcount += ent->plt.refcount;
4742                     *entp = ent->next;
4743                     break;
4744                   }
4745               if (dent == NULL)
4746                 entp = &ent->next;
4747             }
4748           *entp = to->elf.plt.plist;
4749         }
4750
4751       to->elf.plt.plist = from->elf.plt.plist;
4752       from->elf.plt.plist = NULL;
4753     }
4754 }
4755
4756 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4757
4758 static void
4759 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4760                                 struct elf_link_hash_entry *dir,
4761                                 struct elf_link_hash_entry *ind)
4762 {
4763   struct ppc_link_hash_entry *edir, *eind;
4764
4765   edir = (struct ppc_link_hash_entry *) dir;
4766   eind = (struct ppc_link_hash_entry *) ind;
4767
4768   edir->is_func |= eind->is_func;
4769   edir->is_func_descriptor |= eind->is_func_descriptor;
4770   edir->tls_mask |= eind->tls_mask;
4771   if (eind->oh != NULL)
4772     edir->oh = ppc_follow_link (eind->oh);
4773
4774   /* If called to transfer flags for a weakdef during processing
4775      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4776      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4777   if (!(ELIMINATE_COPY_RELOCS
4778         && eind->elf.root.type != bfd_link_hash_indirect
4779         && edir->elf.dynamic_adjusted))
4780     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4781
4782   if (edir->elf.versioned != versioned_hidden)
4783     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4784   edir->elf.ref_regular |= eind->elf.ref_regular;
4785   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4786   edir->elf.needs_plt |= eind->elf.needs_plt;
4787   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4788
4789   /* If we were called to copy over info for a weak sym, don't copy
4790      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4791      in order to simplify readonly_dynrelocs and save a field in the
4792      symbol hash entry, but that means dyn_relocs can't be used in any
4793      tests about a specific symbol, or affect other symbol flags which
4794      are then tested.
4795      Chain weakdefs so we can get from the weakdef back to an alias.
4796      The list is circular so that we don't need to use u.weakdef as
4797      well as this list to look at all aliases.  */
4798   if (eind->elf.root.type != bfd_link_hash_indirect)
4799     {
4800       struct ppc_link_hash_entry *cur, *add, *next;
4801
4802       add = eind;
4803       do
4804         {
4805           cur = edir->weakref;
4806           if (cur != NULL)
4807             {
4808               do
4809                 {
4810                   /* We can be called twice for the same symbols.
4811                      Don't make multiple loops.  */
4812                   if (cur == add)
4813                     return;
4814                   cur = cur->weakref;
4815                 } while (cur != edir);
4816             }
4817           next = add->weakref;
4818           if (cur != add)
4819             {
4820               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4821               edir->weakref = add;
4822             }
4823           add = next;
4824         } while (add != NULL && add != eind);
4825       return;
4826     }
4827
4828   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4829   if (eind->dyn_relocs != NULL)
4830     {
4831       if (edir->dyn_relocs != NULL)
4832         {
4833           struct elf_dyn_relocs **pp;
4834           struct elf_dyn_relocs *p;
4835
4836           /* Add reloc counts against the indirect sym to the direct sym
4837              list.  Merge any entries against the same section.  */
4838           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4839             {
4840               struct elf_dyn_relocs *q;
4841
4842               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4843                 if (q->sec == p->sec)
4844                   {
4845                     q->pc_count += p->pc_count;
4846                     q->count += p->count;
4847                     *pp = p->next;
4848                     break;
4849                   }
4850               if (q == NULL)
4851                 pp = &p->next;
4852             }
4853           *pp = edir->dyn_relocs;
4854         }
4855
4856       edir->dyn_relocs = eind->dyn_relocs;
4857       eind->dyn_relocs = NULL;
4858     }
4859
4860   /* Copy over got entries that we may have already seen to the
4861      symbol which just became indirect.  */
4862   if (eind->elf.got.glist != NULL)
4863     {
4864       if (edir->elf.got.glist != NULL)
4865         {
4866           struct got_entry **entp;
4867           struct got_entry *ent;
4868
4869           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4870             {
4871               struct got_entry *dent;
4872
4873               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4874                 if (dent->addend == ent->addend
4875                     && dent->owner == ent->owner
4876                     && dent->tls_type == ent->tls_type)
4877                   {
4878                     dent->got.refcount += ent->got.refcount;
4879                     *entp = ent->next;
4880                     break;
4881                   }
4882               if (dent == NULL)
4883                 entp = &ent->next;
4884             }
4885           *entp = edir->elf.got.glist;
4886         }
4887
4888       edir->elf.got.glist = eind->elf.got.glist;
4889       eind->elf.got.glist = NULL;
4890     }
4891
4892   /* And plt entries.  */
4893   move_plt_plist (eind, edir);
4894
4895   if (eind->elf.dynindx != -1)
4896     {
4897       if (edir->elf.dynindx != -1)
4898         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4899                                 edir->elf.dynstr_index);
4900       edir->elf.dynindx = eind->elf.dynindx;
4901       edir->elf.dynstr_index = eind->elf.dynstr_index;
4902       eind->elf.dynindx = -1;
4903       eind->elf.dynstr_index = 0;
4904     }
4905 }
4906
4907 /* Find the function descriptor hash entry from the given function code
4908    hash entry FH.  Link the entries via their OH fields.  */
4909
4910 static struct ppc_link_hash_entry *
4911 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4912 {
4913   struct ppc_link_hash_entry *fdh = fh->oh;
4914
4915   if (fdh == NULL)
4916     {
4917       const char *fd_name = fh->elf.root.root.string + 1;
4918
4919       fdh = (struct ppc_link_hash_entry *)
4920         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4921       if (fdh == NULL)
4922         return fdh;
4923
4924       fdh->is_func_descriptor = 1;
4925       fdh->oh = fh;
4926       fh->is_func = 1;
4927       fh->oh = fdh;
4928     }
4929
4930   fdh = ppc_follow_link (fdh);
4931   fdh->is_func_descriptor = 1;
4932   fdh->oh = fh;
4933   return fdh;
4934 }
4935
4936 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4937
4938 static struct ppc_link_hash_entry *
4939 make_fdh (struct bfd_link_info *info,
4940           struct ppc_link_hash_entry *fh)
4941 {
4942   bfd *abfd = fh->elf.root.u.undef.abfd;
4943   struct bfd_link_hash_entry *bh = NULL;
4944   struct ppc_link_hash_entry *fdh;
4945   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4946                     ? BSF_WEAK
4947                     : BSF_GLOBAL);
4948
4949   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4950                                          fh->elf.root.root.string + 1,
4951                                          flags, bfd_und_section_ptr, 0,
4952                                          NULL, FALSE, FALSE, &bh))
4953     return NULL;
4954
4955   fdh = (struct ppc_link_hash_entry *) bh;
4956   fdh->elf.non_elf = 0;
4957   fdh->fake = 1;
4958   fdh->is_func_descriptor = 1;
4959   fdh->oh = fh;
4960   fh->is_func = 1;
4961   fh->oh = fdh;
4962   return fdh;
4963 }
4964
4965 /* Fix function descriptor symbols defined in .opd sections to be
4966    function type.  */
4967
4968 static bfd_boolean
4969 ppc64_elf_add_symbol_hook (bfd *ibfd,
4970                            struct bfd_link_info *info,
4971                            Elf_Internal_Sym *isym,
4972                            const char **name,
4973                            flagword *flags ATTRIBUTE_UNUSED,
4974                            asection **sec,
4975                            bfd_vma *value)
4976 {
4977   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4978       && (ibfd->flags & DYNAMIC) == 0
4979       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4980     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4981
4982   if (*sec != NULL
4983       && strcmp ((*sec)->name, ".opd") == 0)
4984     {
4985       asection *code_sec;
4986
4987       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4988             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4989         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4990
4991       /* If the symbol is a function defined in .opd, and the function
4992          code is in a discarded group, let it appear to be undefined.  */
4993       if (!bfd_link_relocatable (info)
4994           && (*sec)->reloc_count != 0
4995           && opd_entry_value (*sec, *value, &code_sec, NULL,
4996                               FALSE) != (bfd_vma) -1
4997           && discarded_section (code_sec))
4998         {
4999           *sec = bfd_und_section_ptr;
5000           isym->st_shndx = SHN_UNDEF;
5001         }
5002     }
5003   else if (*sec != NULL
5004            && strcmp ((*sec)->name, ".toc") == 0
5005            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5006     {
5007       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5008       if (htab != NULL)
5009         htab->params->object_in_toc = 1;
5010     }
5011
5012   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5013     {
5014       if (abiversion (ibfd) == 0)
5015         set_abiversion (ibfd, 2);
5016       else if (abiversion (ibfd) == 1)
5017         {
5018           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
5019                                     " for ABI version 1\n"), name);
5020           bfd_set_error (bfd_error_bad_value);
5021           return FALSE;
5022         }
5023     }
5024
5025   return TRUE;
5026 }
5027
5028 /* Merge non-visibility st_other attributes: local entry point.  */
5029
5030 static void
5031 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5032                                   const Elf_Internal_Sym *isym,
5033                                   bfd_boolean definition,
5034                                   bfd_boolean dynamic)
5035 {
5036   if (definition && (!dynamic || !h->def_regular))
5037     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5038                 | ELF_ST_VISIBILITY (h->other));
5039 }
5040
5041 /* Hook called on merging a symbol.  We use this to clear "fake" since
5042    we now have a real symbol.  */
5043
5044 static bfd_boolean
5045 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5046                         const Elf_Internal_Sym *isym,
5047                         asection **psec ATTRIBUTE_UNUSED,
5048                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5049                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5050                         bfd *oldbfd ATTRIBUTE_UNUSED,
5051                         const asection *oldsec ATTRIBUTE_UNUSED)
5052 {
5053   ((struct ppc_link_hash_entry *) h)->fake = 0;
5054   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5055     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5056   return TRUE;
5057 }
5058
5059 /* This function makes an old ABI object reference to ".bar" cause the
5060    inclusion of a new ABI object archive that defines "bar".
5061    NAME is a symbol defined in an archive.  Return a symbol in the hash
5062    table that might be satisfied by the archive symbols.  */
5063
5064 static struct elf_link_hash_entry *
5065 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5066                                  struct bfd_link_info *info,
5067                                  const char *name)
5068 {
5069   struct elf_link_hash_entry *h;
5070   char *dot_name;
5071   size_t len;
5072
5073   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5074   if (h != NULL
5075       /* Don't return this sym if it is a fake function descriptor
5076          created by add_symbol_adjust.  */
5077       && !((struct ppc_link_hash_entry *) h)->fake)
5078     return h;
5079
5080   if (name[0] == '.')
5081     return h;
5082
5083   len = strlen (name);
5084   dot_name = bfd_alloc (abfd, len + 2);
5085   if (dot_name == NULL)
5086     return (struct elf_link_hash_entry *) 0 - 1;
5087   dot_name[0] = '.';
5088   memcpy (dot_name + 1, name, len + 1);
5089   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5090   bfd_release (abfd, dot_name);
5091   return h;
5092 }
5093
5094 /* This function satisfies all old ABI object references to ".bar" if a
5095    new ABI object defines "bar".  Well, at least, undefined dot symbols
5096    are made weak.  This stops later archive searches from including an
5097    object if we already have a function descriptor definition.  It also
5098    prevents the linker complaining about undefined symbols.
5099    We also check and correct mismatched symbol visibility here.  The
5100    most restrictive visibility of the function descriptor and the
5101    function entry symbol is used.  */
5102
5103 static bfd_boolean
5104 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5105 {
5106   struct ppc_link_hash_table *htab;
5107   struct ppc_link_hash_entry *fdh;
5108
5109   if (eh->elf.root.type == bfd_link_hash_warning)
5110     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5111
5112   if (eh->elf.root.type == bfd_link_hash_indirect)
5113     return TRUE;
5114
5115   if (eh->elf.root.root.string[0] != '.')
5116     abort ();
5117
5118   htab = ppc_hash_table (info);
5119   if (htab == NULL)
5120     return FALSE;
5121
5122   fdh = lookup_fdh (eh, htab);
5123   if (fdh == NULL
5124       && !bfd_link_relocatable (info)
5125       && (eh->elf.root.type == bfd_link_hash_undefined
5126           || eh->elf.root.type == bfd_link_hash_undefweak)
5127       && eh->elf.ref_regular)
5128     {
5129       /* Make an undefined function descriptor sym, in order to
5130          pull in an --as-needed shared lib.  Archives are handled
5131          elsewhere.  */
5132       fdh = make_fdh (info, eh);
5133       if (fdh == NULL)
5134         return FALSE;
5135     }
5136
5137   if (fdh != NULL)
5138     {
5139       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5140       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5141
5142       /* Make both descriptor and entry symbol have the most
5143          constraining visibility of either symbol.  */
5144       if (entry_vis < descr_vis)
5145         fdh->elf.other += entry_vis - descr_vis;
5146       else if (entry_vis > descr_vis)
5147         eh->elf.other += descr_vis - entry_vis;
5148
5149       /* Propagate reference flags from entry symbol to function
5150          descriptor symbol.  */
5151       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5152       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5153       fdh->elf.ref_regular |= eh->elf.ref_regular;
5154       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5155
5156       if (!fdh->elf.forced_local
5157           && fdh->elf.dynindx == -1
5158           && fdh->elf.versioned != versioned_hidden
5159           && (bfd_link_dll (info)
5160               || fdh->elf.def_dynamic
5161               || fdh->elf.ref_dynamic)
5162           && (eh->elf.ref_regular
5163               || eh->elf.def_regular))
5164         {
5165           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5166             return FALSE;
5167         }
5168     }
5169
5170   return TRUE;
5171 }
5172
5173 /* Set up opd section info and abiversion for IBFD, and process list
5174    of dot-symbols we made in link_hash_newfunc.  */
5175
5176 static bfd_boolean
5177 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5178 {
5179   struct ppc_link_hash_table *htab;
5180   struct ppc_link_hash_entry **p, *eh;
5181   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5182
5183   if (opd != NULL && opd->size != 0)
5184     {
5185       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5186       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5187
5188       if (abiversion (ibfd) == 0)
5189         set_abiversion (ibfd, 1);
5190       else if (abiversion (ibfd) >= 2)
5191         {
5192           /* xgettext:c-format */
5193           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5194                                     " version %d\n"),
5195                                   ibfd, abiversion (ibfd));
5196           bfd_set_error (bfd_error_bad_value);
5197           return FALSE;
5198         }
5199     }
5200
5201   if (is_ppc64_elf (info->output_bfd))
5202     {
5203       /* For input files without an explicit abiversion in e_flags
5204          we should have flagged any with symbol st_other bits set
5205          as ELFv1 and above flagged those with .opd as ELFv2.
5206          Set the output abiversion if not yet set, and for any input
5207          still ambiguous, take its abiversion from the output.
5208          Differences in ABI are reported later.  */
5209       if (abiversion (info->output_bfd) == 0)
5210         set_abiversion (info->output_bfd, abiversion (ibfd));
5211       else if (abiversion (ibfd) == 0)
5212         set_abiversion (ibfd, abiversion (info->output_bfd));
5213     }
5214
5215   htab = ppc_hash_table (info);
5216   if (htab == NULL)
5217     return TRUE;
5218
5219   if (opd != NULL && opd->size != 0
5220       && (ibfd->flags & DYNAMIC) == 0
5221       && (opd->flags & SEC_RELOC) != 0
5222       && opd->reloc_count != 0
5223       && !bfd_is_abs_section (opd->output_section)
5224       && info->gc_sections)
5225     {
5226       /* Garbage collection needs some extra help with .opd sections.
5227          We don't want to necessarily keep everything referenced by
5228          relocs in .opd, as that would keep all functions.  Instead,
5229          if we reference an .opd symbol (a function descriptor), we
5230          want to keep the function code symbol's section.  This is
5231          easy for global symbols, but for local syms we need to keep
5232          information about the associated function section.  */
5233       bfd_size_type amt;
5234       asection **opd_sym_map;
5235       Elf_Internal_Shdr *symtab_hdr;
5236       Elf_Internal_Rela *relocs, *rel_end, *rel;
5237
5238       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5239       opd_sym_map = bfd_zalloc (ibfd, amt);
5240       if (opd_sym_map == NULL)
5241         return FALSE;
5242       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5243       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5244                                           info->keep_memory);
5245       if (relocs == NULL)
5246         return FALSE;
5247       symtab_hdr = &elf_symtab_hdr (ibfd);
5248       rel_end = relocs + opd->reloc_count - 1;
5249       for (rel = relocs; rel < rel_end; rel++)
5250         {
5251           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5252           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5253
5254           if (r_type == R_PPC64_ADDR64
5255               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5256               && r_symndx < symtab_hdr->sh_info)
5257             {
5258               Elf_Internal_Sym *isym;
5259               asection *s;
5260
5261               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5262               if (isym == NULL)
5263                 {
5264                   if (elf_section_data (opd)->relocs != relocs)
5265                     free (relocs);
5266                   return FALSE;
5267                 }
5268
5269               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5270               if (s != NULL && s != opd)
5271                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5272             }
5273         }
5274       if (elf_section_data (opd)->relocs != relocs)
5275         free (relocs);
5276     }
5277
5278   p = &htab->dot_syms;
5279   while ((eh = *p) != NULL)
5280     {
5281       *p = NULL;
5282       if (&eh->elf == htab->elf.hgot)
5283         ;
5284       else if (htab->elf.hgot == NULL
5285                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5286         htab->elf.hgot = &eh->elf;
5287       else if (abiversion (ibfd) <= 1)
5288         {
5289           htab->need_func_desc_adj = 1;
5290           if (!add_symbol_adjust (eh, info))
5291             return FALSE;
5292         }
5293       p = &eh->u.next_dot_sym;
5294     }
5295   return TRUE;
5296 }
5297
5298 /* Undo hash table changes when an --as-needed input file is determined
5299    not to be needed.  */
5300
5301 static bfd_boolean
5302 ppc64_elf_notice_as_needed (bfd *ibfd,
5303                             struct bfd_link_info *info,
5304                             enum notice_asneeded_action act)
5305 {
5306   if (act == notice_not_needed)
5307     {
5308       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5309
5310       if (htab == NULL)
5311         return FALSE;
5312
5313       htab->dot_syms = NULL;
5314     }
5315   return _bfd_elf_notice_as_needed (ibfd, info, act);
5316 }
5317
5318 /* If --just-symbols against a final linked binary, then assume we need
5319    toc adjusting stubs when calling functions defined there.  */
5320
5321 static void
5322 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5323 {
5324   if ((sec->flags & SEC_CODE) != 0
5325       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5326       && is_ppc64_elf (sec->owner))
5327     {
5328       if (abiversion (sec->owner) >= 2
5329           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5330         sec->has_toc_reloc = 1;
5331     }
5332   _bfd_elf_link_just_syms (sec, info);
5333 }
5334
5335 static struct plt_entry **
5336 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5337                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5338 {
5339   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5340   struct plt_entry **local_plt;
5341   unsigned char *local_got_tls_masks;
5342
5343   if (local_got_ents == NULL)
5344     {
5345       bfd_size_type size = symtab_hdr->sh_info;
5346
5347       size *= (sizeof (*local_got_ents)
5348                + sizeof (*local_plt)
5349                + sizeof (*local_got_tls_masks));
5350       local_got_ents = bfd_zalloc (abfd, size);
5351       if (local_got_ents == NULL)
5352         return NULL;
5353       elf_local_got_ents (abfd) = local_got_ents;
5354     }
5355
5356   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5357     {
5358       struct got_entry *ent;
5359
5360       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5361         if (ent->addend == r_addend
5362             && ent->owner == abfd
5363             && ent->tls_type == tls_type)
5364           break;
5365       if (ent == NULL)
5366         {
5367           bfd_size_type amt = sizeof (*ent);
5368           ent = bfd_alloc (abfd, amt);
5369           if (ent == NULL)
5370             return FALSE;
5371           ent->next = local_got_ents[r_symndx];
5372           ent->addend = r_addend;
5373           ent->owner = abfd;
5374           ent->tls_type = tls_type;
5375           ent->is_indirect = FALSE;
5376           ent->got.refcount = 0;
5377           local_got_ents[r_symndx] = ent;
5378         }
5379       ent->got.refcount += 1;
5380     }
5381
5382   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5383   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5384   local_got_tls_masks[r_symndx] |= tls_type;
5385
5386   return local_plt + r_symndx;
5387 }
5388
5389 static bfd_boolean
5390 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5391 {
5392   struct plt_entry *ent;
5393
5394   for (ent = *plist; ent != NULL; ent = ent->next)
5395     if (ent->addend == addend)
5396       break;
5397   if (ent == NULL)
5398     {
5399       bfd_size_type amt = sizeof (*ent);
5400       ent = bfd_alloc (abfd, amt);
5401       if (ent == NULL)
5402         return FALSE;
5403       ent->next = *plist;
5404       ent->addend = addend;
5405       ent->plt.refcount = 0;
5406       *plist = ent;
5407     }
5408   ent->plt.refcount += 1;
5409   return TRUE;
5410 }
5411
5412 static bfd_boolean
5413 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5414 {
5415   return (r_type == R_PPC64_REL24
5416           || r_type == R_PPC64_REL14
5417           || r_type == R_PPC64_REL14_BRTAKEN
5418           || r_type == R_PPC64_REL14_BRNTAKEN
5419           || r_type == R_PPC64_ADDR24
5420           || r_type == R_PPC64_ADDR14
5421           || r_type == R_PPC64_ADDR14_BRTAKEN
5422           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5423 }
5424
5425 /* Look through the relocs for a section during the first phase, and
5426    calculate needed space in the global offset table, procedure
5427    linkage table, and dynamic reloc sections.  */
5428
5429 static bfd_boolean
5430 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5431                         asection *sec, const Elf_Internal_Rela *relocs)
5432 {
5433   struct ppc_link_hash_table *htab;
5434   Elf_Internal_Shdr *symtab_hdr;
5435   struct elf_link_hash_entry **sym_hashes;
5436   const Elf_Internal_Rela *rel;
5437   const Elf_Internal_Rela *rel_end;
5438   asection *sreloc;
5439   struct elf_link_hash_entry *tga, *dottga;
5440   bfd_boolean is_opd;
5441
5442   if (bfd_link_relocatable (info))
5443     return TRUE;
5444
5445   /* Don't do anything special with non-loaded, non-alloced sections.
5446      In particular, any relocs in such sections should not affect GOT
5447      and PLT reference counting (ie. we don't allow them to create GOT
5448      or PLT entries), there's no possibility or desire to optimize TLS
5449      relocs, and there's not much point in propagating relocs to shared
5450      libs that the dynamic linker won't relocate.  */
5451   if ((sec->flags & SEC_ALLOC) == 0)
5452     return TRUE;
5453
5454   BFD_ASSERT (is_ppc64_elf (abfd));
5455
5456   htab = ppc_hash_table (info);
5457   if (htab == NULL)
5458     return FALSE;
5459
5460   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5461                               FALSE, FALSE, TRUE);
5462   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5463                                  FALSE, FALSE, TRUE);
5464   symtab_hdr = &elf_symtab_hdr (abfd);
5465   sym_hashes = elf_sym_hashes (abfd);
5466   sreloc = NULL;
5467   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5468   rel_end = relocs + sec->reloc_count;
5469   for (rel = relocs; rel < rel_end; rel++)
5470     {
5471       unsigned long r_symndx;
5472       struct elf_link_hash_entry *h;
5473       enum elf_ppc64_reloc_type r_type;
5474       int tls_type;
5475       struct _ppc64_elf_section_data *ppc64_sec;
5476       struct plt_entry **ifunc, **plt_list;
5477
5478       r_symndx = ELF64_R_SYM (rel->r_info);
5479       if (r_symndx < symtab_hdr->sh_info)
5480         h = NULL;
5481       else
5482         {
5483           struct ppc_link_hash_entry *eh;
5484
5485           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5486           h = elf_follow_link (h);
5487           eh = (struct ppc_link_hash_entry *) h;
5488
5489           /* PR15323, ref flags aren't set for references in the same
5490              object.  */
5491           h->root.non_ir_ref_regular = 1;
5492           if (eh->is_func && eh->oh != NULL)
5493             eh->oh->elf.root.non_ir_ref_regular = 1;
5494
5495           if (h == htab->elf.hgot)
5496             sec->has_toc_reloc = 1;
5497         }
5498
5499       tls_type = 0;
5500       ifunc = NULL;
5501       if (h != NULL)
5502         {
5503           if (h->type == STT_GNU_IFUNC)
5504             {
5505               h->needs_plt = 1;
5506               ifunc = &h->plt.plist;
5507             }
5508         }
5509       else
5510         {
5511           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5512                                                           abfd, r_symndx);
5513           if (isym == NULL)
5514             return FALSE;
5515
5516           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5517             {
5518               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5519                                              rel->r_addend, PLT_IFUNC);
5520               if (ifunc == NULL)
5521                 return FALSE;
5522             }
5523         }
5524
5525       r_type = ELF64_R_TYPE (rel->r_info);
5526       switch (r_type)
5527         {
5528         case R_PPC64_TLSGD:
5529         case R_PPC64_TLSLD:
5530           /* These special tls relocs tie a call to __tls_get_addr with
5531              its parameter symbol.  */
5532           break;
5533
5534         case R_PPC64_GOT_TLSLD16:
5535         case R_PPC64_GOT_TLSLD16_LO:
5536         case R_PPC64_GOT_TLSLD16_HI:
5537         case R_PPC64_GOT_TLSLD16_HA:
5538           tls_type = TLS_TLS | TLS_LD;
5539           goto dogottls;
5540
5541         case R_PPC64_GOT_TLSGD16:
5542         case R_PPC64_GOT_TLSGD16_LO:
5543         case R_PPC64_GOT_TLSGD16_HI:
5544         case R_PPC64_GOT_TLSGD16_HA:
5545           tls_type = TLS_TLS | TLS_GD;
5546           goto dogottls;
5547
5548         case R_PPC64_GOT_TPREL16_DS:
5549         case R_PPC64_GOT_TPREL16_LO_DS:
5550         case R_PPC64_GOT_TPREL16_HI:
5551         case R_PPC64_GOT_TPREL16_HA:
5552           if (bfd_link_dll (info))
5553             info->flags |= DF_STATIC_TLS;
5554           tls_type = TLS_TLS | TLS_TPREL;
5555           goto dogottls;
5556
5557         case R_PPC64_GOT_DTPREL16_DS:
5558         case R_PPC64_GOT_DTPREL16_LO_DS:
5559         case R_PPC64_GOT_DTPREL16_HI:
5560         case R_PPC64_GOT_DTPREL16_HA:
5561           tls_type = TLS_TLS | TLS_DTPREL;
5562         dogottls:
5563           sec->has_tls_reloc = 1;
5564           /* Fall through */
5565
5566         case R_PPC64_GOT16:
5567         case R_PPC64_GOT16_DS:
5568         case R_PPC64_GOT16_HA:
5569         case R_PPC64_GOT16_HI:
5570         case R_PPC64_GOT16_LO:
5571         case R_PPC64_GOT16_LO_DS:
5572           /* This symbol requires a global offset table entry.  */
5573           sec->has_toc_reloc = 1;
5574           if (r_type == R_PPC64_GOT_TLSLD16
5575               || r_type == R_PPC64_GOT_TLSGD16
5576               || r_type == R_PPC64_GOT_TPREL16_DS
5577               || r_type == R_PPC64_GOT_DTPREL16_DS
5578               || r_type == R_PPC64_GOT16
5579               || r_type == R_PPC64_GOT16_DS)
5580             {
5581               htab->do_multi_toc = 1;
5582               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5583             }
5584
5585           if (ppc64_elf_tdata (abfd)->got == NULL
5586               && !create_got_section (abfd, info))
5587             return FALSE;
5588
5589           if (h != NULL)
5590             {
5591               struct ppc_link_hash_entry *eh;
5592               struct got_entry *ent;
5593
5594               eh = (struct ppc_link_hash_entry *) h;
5595               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5596                 if (ent->addend == rel->r_addend
5597                     && ent->owner == abfd
5598                     && ent->tls_type == tls_type)
5599                   break;
5600               if (ent == NULL)
5601                 {
5602                   bfd_size_type amt = sizeof (*ent);
5603                   ent = bfd_alloc (abfd, amt);
5604                   if (ent == NULL)
5605                     return FALSE;
5606                   ent->next = eh->elf.got.glist;
5607                   ent->addend = rel->r_addend;
5608                   ent->owner = abfd;
5609                   ent->tls_type = tls_type;
5610                   ent->is_indirect = FALSE;
5611                   ent->got.refcount = 0;
5612                   eh->elf.got.glist = ent;
5613                 }
5614               ent->got.refcount += 1;
5615               eh->tls_mask |= tls_type;
5616             }
5617           else
5618             /* This is a global offset table entry for a local symbol.  */
5619             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5620                                         rel->r_addend, tls_type))
5621               return FALSE;
5622
5623           /* We may also need a plt entry if the symbol turns out to be
5624              an ifunc.  */
5625           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5626             {
5627               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5628                 return FALSE;
5629             }
5630           break;
5631
5632         case R_PPC64_PLT16_HA:
5633         case R_PPC64_PLT16_HI:
5634         case R_PPC64_PLT16_LO:
5635         case R_PPC64_PLT32:
5636         case R_PPC64_PLT64:
5637           /* This symbol requires a procedure linkage table entry.  */
5638           plt_list = ifunc;
5639           if (h != NULL)
5640             {
5641               h->needs_plt = 1;
5642               if (h->root.root.string[0] == '.'
5643                   && h->root.root.string[1] != '\0')
5644                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5645               plt_list = &h->plt.plist;
5646             }
5647           if (plt_list == NULL)
5648             {
5649               /* It does not make sense to have a procedure linkage
5650                  table entry for a non-ifunc local symbol.  */
5651               info->callbacks->einfo
5652                 /* xgettext:c-format */
5653                 (_("%H: %s reloc against local symbol\n"),
5654                  abfd, sec, rel->r_offset,
5655                  ppc64_elf_howto_table[r_type]->name);
5656               bfd_set_error (bfd_error_bad_value);
5657               return FALSE;
5658             }
5659           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5660             return FALSE;
5661           break;
5662
5663           /* The following relocations don't need to propagate the
5664              relocation if linking a shared object since they are
5665              section relative.  */
5666         case R_PPC64_SECTOFF:
5667         case R_PPC64_SECTOFF_LO:
5668         case R_PPC64_SECTOFF_HI:
5669         case R_PPC64_SECTOFF_HA:
5670         case R_PPC64_SECTOFF_DS:
5671         case R_PPC64_SECTOFF_LO_DS:
5672         case R_PPC64_DTPREL16:
5673         case R_PPC64_DTPREL16_LO:
5674         case R_PPC64_DTPREL16_HI:
5675         case R_PPC64_DTPREL16_HA:
5676         case R_PPC64_DTPREL16_DS:
5677         case R_PPC64_DTPREL16_LO_DS:
5678         case R_PPC64_DTPREL16_HIGH:
5679         case R_PPC64_DTPREL16_HIGHA:
5680         case R_PPC64_DTPREL16_HIGHER:
5681         case R_PPC64_DTPREL16_HIGHERA:
5682         case R_PPC64_DTPREL16_HIGHEST:
5683         case R_PPC64_DTPREL16_HIGHESTA:
5684           break;
5685
5686           /* Nor do these.  */
5687         case R_PPC64_REL16:
5688         case R_PPC64_REL16_LO:
5689         case R_PPC64_REL16_HI:
5690         case R_PPC64_REL16_HA:
5691         case R_PPC64_REL16DX_HA:
5692           break;
5693
5694           /* Not supported as a dynamic relocation.  */
5695         case R_PPC64_ADDR64_LOCAL:
5696           if (bfd_link_pic (info))
5697             {
5698               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5699                 ppc_howto_init ();
5700               /* xgettext:c-format */
5701               info->callbacks->einfo (_("%H: %s reloc unsupported "
5702                                         "in shared libraries and PIEs.\n"),
5703                                       abfd, sec, rel->r_offset,
5704                                       ppc64_elf_howto_table[r_type]->name);
5705               bfd_set_error (bfd_error_bad_value);
5706               return FALSE;
5707             }
5708           break;
5709
5710         case R_PPC64_TOC16:
5711         case R_PPC64_TOC16_DS:
5712           htab->do_multi_toc = 1;
5713           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5714           /* Fall through.  */
5715         case R_PPC64_TOC16_LO:
5716         case R_PPC64_TOC16_HI:
5717         case R_PPC64_TOC16_HA:
5718         case R_PPC64_TOC16_LO_DS:
5719           sec->has_toc_reloc = 1;
5720           break;
5721
5722           /* Marker reloc.  */
5723         case R_PPC64_ENTRY:
5724           break;
5725
5726           /* This relocation describes the C++ object vtable hierarchy.
5727              Reconstruct it for later use during GC.  */
5728         case R_PPC64_GNU_VTINHERIT:
5729           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5730             return FALSE;
5731           break;
5732
5733           /* This relocation describes which C++ vtable entries are actually
5734              used.  Record for later use during GC.  */
5735         case R_PPC64_GNU_VTENTRY:
5736           BFD_ASSERT (h != NULL);
5737           if (h != NULL
5738               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5739             return FALSE;
5740           break;
5741
5742         case R_PPC64_REL14:
5743         case R_PPC64_REL14_BRTAKEN:
5744         case R_PPC64_REL14_BRNTAKEN:
5745           {
5746             asection *dest = NULL;
5747
5748             /* Heuristic: If jumping outside our section, chances are
5749                we are going to need a stub.  */
5750             if (h != NULL)
5751               {
5752                 /* If the sym is weak it may be overridden later, so
5753                    don't assume we know where a weak sym lives.  */
5754                 if (h->root.type == bfd_link_hash_defined)
5755                   dest = h->root.u.def.section;
5756               }
5757             else
5758               {
5759                 Elf_Internal_Sym *isym;
5760
5761                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5762                                               abfd, r_symndx);
5763                 if (isym == NULL)
5764                   return FALSE;
5765
5766                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5767               }
5768
5769             if (dest != sec)
5770               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5771           }
5772           /* Fall through.  */
5773
5774         case R_PPC64_REL24:
5775           plt_list = ifunc;
5776           if (h != NULL)
5777             {
5778               h->needs_plt = 1;
5779               if (h->root.root.string[0] == '.'
5780                   && h->root.root.string[1] != '\0')
5781                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5782
5783               if (h == tga || h == dottga)
5784                 {
5785                   sec->has_tls_reloc = 1;
5786                   if (rel != relocs
5787                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5788                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5789                     /* We have a new-style __tls_get_addr call with
5790                        a marker reloc.  */
5791                     ;
5792                   else
5793                     /* Mark this section as having an old-style call.  */
5794                     sec->has_tls_get_addr_call = 1;
5795                 }
5796               plt_list = &h->plt.plist;
5797             }
5798
5799           /* We may need a .plt entry if the function this reloc
5800              refers to is in a shared lib.  */
5801           if (plt_list
5802               && !update_plt_info (abfd, plt_list, rel->r_addend))
5803             return FALSE;
5804           break;
5805
5806         case R_PPC64_ADDR14:
5807         case R_PPC64_ADDR14_BRNTAKEN:
5808         case R_PPC64_ADDR14_BRTAKEN:
5809         case R_PPC64_ADDR24:
5810           goto dodyn;
5811
5812         case R_PPC64_TPREL64:
5813           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5814           if (bfd_link_dll (info))
5815             info->flags |= DF_STATIC_TLS;
5816           goto dotlstoc;
5817
5818         case R_PPC64_DTPMOD64:
5819           if (rel + 1 < rel_end
5820               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5821               && rel[1].r_offset == rel->r_offset + 8)
5822             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5823           else
5824             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5825           goto dotlstoc;
5826
5827         case R_PPC64_DTPREL64:
5828           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5829           if (rel != relocs
5830               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5831               && rel[-1].r_offset == rel->r_offset - 8)
5832             /* This is the second reloc of a dtpmod, dtprel pair.
5833                Don't mark with TLS_DTPREL.  */
5834             goto dodyn;
5835
5836         dotlstoc:
5837           sec->has_tls_reloc = 1;
5838           if (h != NULL)
5839             {
5840               struct ppc_link_hash_entry *eh;
5841               eh = (struct ppc_link_hash_entry *) h;
5842               eh->tls_mask |= tls_type;
5843             }
5844           else
5845             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5846                                         rel->r_addend, tls_type))
5847               return FALSE;
5848
5849           ppc64_sec = ppc64_elf_section_data (sec);
5850           if (ppc64_sec->sec_type != sec_toc)
5851             {
5852               bfd_size_type amt;
5853
5854               /* One extra to simplify get_tls_mask.  */
5855               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5856               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5857               if (ppc64_sec->u.toc.symndx == NULL)
5858                 return FALSE;
5859               amt = sec->size * sizeof (bfd_vma) / 8;
5860               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5861               if (ppc64_sec->u.toc.add == NULL)
5862                 return FALSE;
5863               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5864               ppc64_sec->sec_type = sec_toc;
5865             }
5866           BFD_ASSERT (rel->r_offset % 8 == 0);
5867           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5868           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5869
5870           /* Mark the second slot of a GD or LD entry.
5871              -1 to indicate GD and -2 to indicate LD.  */
5872           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5873             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5874           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5875             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5876           goto dodyn;
5877
5878         case R_PPC64_TPREL16:
5879         case R_PPC64_TPREL16_LO:
5880         case R_PPC64_TPREL16_HI:
5881         case R_PPC64_TPREL16_HA:
5882         case R_PPC64_TPREL16_DS:
5883         case R_PPC64_TPREL16_LO_DS:
5884         case R_PPC64_TPREL16_HIGH:
5885         case R_PPC64_TPREL16_HIGHA:
5886         case R_PPC64_TPREL16_HIGHER:
5887         case R_PPC64_TPREL16_HIGHERA:
5888         case R_PPC64_TPREL16_HIGHEST:
5889         case R_PPC64_TPREL16_HIGHESTA:
5890           if (bfd_link_dll (info))
5891             info->flags |= DF_STATIC_TLS;
5892           goto dodyn;
5893
5894         case R_PPC64_ADDR64:
5895           if (is_opd
5896               && rel + 1 < rel_end
5897               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5898             {
5899               if (h != NULL)
5900                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5901             }
5902           /* Fall through.  */
5903
5904         case R_PPC64_ADDR16:
5905         case R_PPC64_ADDR16_DS:
5906         case R_PPC64_ADDR16_HA:
5907         case R_PPC64_ADDR16_HI:
5908         case R_PPC64_ADDR16_HIGH:
5909         case R_PPC64_ADDR16_HIGHA:
5910         case R_PPC64_ADDR16_HIGHER:
5911         case R_PPC64_ADDR16_HIGHERA:
5912         case R_PPC64_ADDR16_HIGHEST:
5913         case R_PPC64_ADDR16_HIGHESTA:
5914         case R_PPC64_ADDR16_LO:
5915         case R_PPC64_ADDR16_LO_DS:
5916           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5917               && rel->r_addend == 0)
5918             {
5919               /* We may need a .plt entry if this reloc refers to a
5920                  function in a shared lib.  */
5921               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5922                 return FALSE;
5923               h->pointer_equality_needed = 1;
5924             }
5925           /* Fall through.  */
5926
5927         case R_PPC64_REL30:
5928         case R_PPC64_REL32:
5929         case R_PPC64_REL64:
5930         case R_PPC64_ADDR32:
5931         case R_PPC64_UADDR16:
5932         case R_PPC64_UADDR32:
5933         case R_PPC64_UADDR64:
5934         case R_PPC64_TOC:
5935           if (h != NULL && !bfd_link_pic (info))
5936             /* We may need a copy reloc.  */
5937             h->non_got_ref = 1;
5938
5939           /* Don't propagate .opd relocs.  */
5940           if (NO_OPD_RELOCS && is_opd)
5941             break;
5942
5943           /* If we are creating a shared library, and this is a reloc
5944              against a global symbol, or a non PC relative reloc
5945              against a local symbol, then we need to copy the reloc
5946              into the shared library.  However, if we are linking with
5947              -Bsymbolic, we do not need to copy a reloc against a
5948              global symbol which is defined in an object we are
5949              including in the link (i.e., DEF_REGULAR is set).  At
5950              this point we have not seen all the input files, so it is
5951              possible that DEF_REGULAR is not set now but will be set
5952              later (it is never cleared).  In case of a weak definition,
5953              DEF_REGULAR may be cleared later by a strong definition in
5954              a shared library.  We account for that possibility below by
5955              storing information in the dyn_relocs field of the hash
5956              table entry.  A similar situation occurs when creating
5957              shared libraries and symbol visibility changes render the
5958              symbol local.
5959
5960              If on the other hand, we are creating an executable, we
5961              may need to keep relocations for symbols satisfied by a
5962              dynamic library if we manage to avoid copy relocs for the
5963              symbol.  */
5964         dodyn:
5965           if ((bfd_link_pic (info)
5966                && (must_be_dyn_reloc (info, r_type)
5967                    || (h != NULL
5968                        && (!SYMBOLIC_BIND (info, h)
5969                            || h->root.type == bfd_link_hash_defweak
5970                            || !h->def_regular))))
5971               || (ELIMINATE_COPY_RELOCS
5972                   && !bfd_link_pic (info)
5973                   && h != NULL
5974                   && (h->root.type == bfd_link_hash_defweak
5975                       || !h->def_regular))
5976               || (!bfd_link_pic (info)
5977                   && ifunc != NULL))
5978             {
5979               /* We must copy these reloc types into the output file.
5980                  Create a reloc section in dynobj and make room for
5981                  this reloc.  */
5982               if (sreloc == NULL)
5983                 {
5984                   sreloc = _bfd_elf_make_dynamic_reloc_section
5985                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5986
5987                   if (sreloc == NULL)
5988                     return FALSE;
5989                 }
5990
5991               /* If this is a global symbol, we count the number of
5992                  relocations we need for this symbol.  */
5993               if (h != NULL)
5994                 {
5995                   struct elf_dyn_relocs *p;
5996                   struct elf_dyn_relocs **head;
5997
5998                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5999                   p = *head;
6000                   if (p == NULL || p->sec != sec)
6001                     {
6002                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6003                       if (p == NULL)
6004                         return FALSE;
6005                       p->next = *head;
6006                       *head = p;
6007                       p->sec = sec;
6008                       p->count = 0;
6009                       p->pc_count = 0;
6010                     }
6011                   p->count += 1;
6012                   if (!must_be_dyn_reloc (info, r_type))
6013                     p->pc_count += 1;
6014                 }
6015               else
6016                 {
6017                   /* Track dynamic relocs needed for local syms too.
6018                      We really need local syms available to do this
6019                      easily.  Oh well.  */
6020                   struct ppc_dyn_relocs *p;
6021                   struct ppc_dyn_relocs **head;
6022                   bfd_boolean is_ifunc;
6023                   asection *s;
6024                   void *vpp;
6025                   Elf_Internal_Sym *isym;
6026
6027                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6028                                                 abfd, r_symndx);
6029                   if (isym == NULL)
6030                     return FALSE;
6031
6032                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6033                   if (s == NULL)
6034                     s = sec;
6035
6036                   vpp = &elf_section_data (s)->local_dynrel;
6037                   head = (struct ppc_dyn_relocs **) vpp;
6038                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6039                   p = *head;
6040                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6041                     p = p->next;
6042                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6043                     {
6044                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6045                       if (p == NULL)
6046                         return FALSE;
6047                       p->next = *head;
6048                       *head = p;
6049                       p->sec = sec;
6050                       p->ifunc = is_ifunc;
6051                       p->count = 0;
6052                     }
6053                   p->count += 1;
6054                 }
6055             }
6056           break;
6057
6058         default:
6059           break;
6060         }
6061     }
6062
6063   return TRUE;
6064 }
6065
6066 /* Merge backend specific data from an object file to the output
6067    object file when linking.  */
6068
6069 static bfd_boolean
6070 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6071 {
6072   bfd *obfd = info->output_bfd;
6073   unsigned long iflags, oflags;
6074
6075   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6076     return TRUE;
6077
6078   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6079     return TRUE;
6080
6081   if (!_bfd_generic_verify_endian_match (ibfd, info))
6082     return FALSE;
6083
6084   iflags = elf_elfheader (ibfd)->e_flags;
6085   oflags = elf_elfheader (obfd)->e_flags;
6086
6087   if (iflags & ~EF_PPC64_ABI)
6088     {
6089       _bfd_error_handler
6090         /* xgettext:c-format */
6091         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6092       bfd_set_error (bfd_error_bad_value);
6093       return FALSE;
6094     }
6095   else if (iflags != oflags && iflags != 0)
6096     {
6097       _bfd_error_handler
6098         /* xgettext:c-format */
6099         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6100          ibfd, iflags, oflags);
6101       bfd_set_error (bfd_error_bad_value);
6102       return FALSE;
6103     }
6104
6105   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6106
6107   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6108   _bfd_elf_merge_object_attributes (ibfd, info);
6109
6110   return TRUE;
6111 }
6112
6113 static bfd_boolean
6114 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6115 {
6116   /* Print normal ELF private data.  */
6117   _bfd_elf_print_private_bfd_data (abfd, ptr);
6118
6119   if (elf_elfheader (abfd)->e_flags != 0)
6120     {
6121       FILE *file = ptr;
6122
6123       fprintf (file, _("private flags = 0x%lx:"),
6124                elf_elfheader (abfd)->e_flags);
6125
6126       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6127         fprintf (file, _(" [abiv%ld]"),
6128                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6129       fputc ('\n', file);
6130     }
6131
6132   return TRUE;
6133 }
6134
6135 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6136    of the code entry point, and its section, which must be in the same
6137    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6138
6139 static bfd_vma
6140 opd_entry_value (asection *opd_sec,
6141                  bfd_vma offset,
6142                  asection **code_sec,
6143                  bfd_vma *code_off,
6144                  bfd_boolean in_code_sec)
6145 {
6146   bfd *opd_bfd = opd_sec->owner;
6147   Elf_Internal_Rela *relocs;
6148   Elf_Internal_Rela *lo, *hi, *look;
6149   bfd_vma val;
6150
6151   /* No relocs implies we are linking a --just-symbols object, or looking
6152      at a final linked executable with addr2line or somesuch.  */
6153   if (opd_sec->reloc_count == 0)
6154     {
6155       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6156
6157       if (contents == NULL)
6158         {
6159           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6160             return (bfd_vma) -1;
6161           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6162         }
6163
6164       /* PR 17512: file: 64b9dfbb.  */
6165       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6166         return (bfd_vma) -1;
6167
6168       val = bfd_get_64 (opd_bfd, contents + offset);
6169       if (code_sec != NULL)
6170         {
6171           asection *sec, *likely = NULL;
6172
6173           if (in_code_sec)
6174             {
6175               sec = *code_sec;
6176               if (sec->vma <= val
6177                   && val < sec->vma + sec->size)
6178                 likely = sec;
6179               else
6180                 val = -1;
6181             }
6182           else
6183             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6184               if (sec->vma <= val
6185                   && (sec->flags & SEC_LOAD) != 0
6186                   && (sec->flags & SEC_ALLOC) != 0)
6187                 likely = sec;
6188           if (likely != NULL)
6189             {
6190               *code_sec = likely;
6191               if (code_off != NULL)
6192                 *code_off = val - likely->vma;
6193             }
6194         }
6195       return val;
6196     }
6197
6198   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6199
6200   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6201   if (relocs == NULL)
6202     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6203   /* PR 17512: file: df8e1fd6.  */
6204   if (relocs == NULL)
6205     return (bfd_vma) -1;
6206
6207   /* Go find the opd reloc at the sym address.  */
6208   lo = relocs;
6209   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6210   val = (bfd_vma) -1;
6211   while (lo < hi)
6212     {
6213       look = lo + (hi - lo) / 2;
6214       if (look->r_offset < offset)
6215         lo = look + 1;
6216       else if (look->r_offset > offset)
6217         hi = look;
6218       else
6219         {
6220           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6221
6222           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6223               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6224             {
6225               unsigned long symndx = ELF64_R_SYM (look->r_info);
6226               asection *sec = NULL;
6227
6228               if (symndx >= symtab_hdr->sh_info
6229                   && elf_sym_hashes (opd_bfd) != NULL)
6230                 {
6231                   struct elf_link_hash_entry **sym_hashes;
6232                   struct elf_link_hash_entry *rh;
6233
6234                   sym_hashes = elf_sym_hashes (opd_bfd);
6235                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6236                   if (rh != NULL)
6237                     {
6238                       rh = elf_follow_link (rh);
6239                       if (rh->root.type != bfd_link_hash_defined
6240                           && rh->root.type != bfd_link_hash_defweak)
6241                         break;
6242                       if (rh->root.u.def.section->owner == opd_bfd)
6243                         {
6244                           val = rh->root.u.def.value;
6245                           sec = rh->root.u.def.section;
6246                         }
6247                     }
6248                 }
6249
6250               if (sec == NULL)
6251                 {
6252                   Elf_Internal_Sym *sym;
6253
6254                   if (symndx < symtab_hdr->sh_info)
6255                     {
6256                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6257                       if (sym == NULL)
6258                         {
6259                           size_t symcnt = symtab_hdr->sh_info;
6260                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6261                                                       symcnt, 0,
6262                                                       NULL, NULL, NULL);
6263                           if (sym == NULL)
6264                             break;
6265                           symtab_hdr->contents = (bfd_byte *) sym;
6266                         }
6267                       sym += symndx;
6268                     }
6269                   else
6270                     {
6271                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6272                                                   1, symndx,
6273                                                   NULL, NULL, NULL);
6274                       if (sym == NULL)
6275                         break;
6276                     }
6277                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6278                   if (sec == NULL)
6279                     break;
6280                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6281                   val = sym->st_value;
6282                 }
6283
6284               val += look->r_addend;
6285               if (code_off != NULL)
6286                 *code_off = val;
6287               if (code_sec != NULL)
6288                 {
6289                   if (in_code_sec && *code_sec != sec)
6290                     return -1;
6291                   else
6292                     *code_sec = sec;
6293                 }
6294               if (sec->output_section != NULL)
6295                 val += sec->output_section->vma + sec->output_offset;
6296             }
6297           break;
6298         }
6299     }
6300
6301   return val;
6302 }
6303
6304 /* If the ELF symbol SYM might be a function in SEC, return the
6305    function size and set *CODE_OFF to the function's entry point,
6306    otherwise return zero.  */
6307
6308 static bfd_size_type
6309 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6310                               bfd_vma *code_off)
6311 {
6312   bfd_size_type size;
6313
6314   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6315                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6316     return 0;
6317
6318   size = 0;
6319   if (!(sym->flags & BSF_SYNTHETIC))
6320     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6321
6322   if (strcmp (sym->section->name, ".opd") == 0)
6323     {
6324       struct _opd_sec_data *opd = get_opd_info (sym->section);
6325       bfd_vma symval = sym->value;
6326
6327       if (opd != NULL
6328           && opd->adjust != NULL
6329           && elf_section_data (sym->section)->relocs != NULL)
6330         {
6331           /* opd_entry_value will use cached relocs that have been
6332              adjusted, but with raw symbols.  That means both local
6333              and global symbols need adjusting.  */
6334           long adjust = opd->adjust[OPD_NDX (symval)];
6335           if (adjust == -1)
6336             return 0;
6337           symval += adjust;
6338         }
6339
6340       if (opd_entry_value (sym->section, symval,
6341                            &sec, code_off, TRUE) == (bfd_vma) -1)
6342         return 0;
6343       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6344          symbol.  This size has nothing to do with the code size of the
6345          function, which is what we're supposed to return, but the
6346          code size isn't available without looking up the dot-sym.
6347          However, doing that would be a waste of time particularly
6348          since elf_find_function will look at the dot-sym anyway.
6349          Now, elf_find_function will keep the largest size of any
6350          function sym found at the code address of interest, so return
6351          1 here to avoid it incorrectly caching a larger function size
6352          for a small function.  This does mean we return the wrong
6353          size for a new-ABI function of size 24, but all that does is
6354          disable caching for such functions.  */
6355       if (size == 24)
6356         size = 1;
6357     }
6358   else
6359     {
6360       if (sym->section != sec)
6361         return 0;
6362       *code_off = sym->value;
6363     }
6364   if (size == 0)
6365     size = 1;
6366   return size;
6367 }
6368
6369 /* Return true if symbol is a strong function defined in an ELFv2
6370    object with st_other localentry bits of zero, ie. its local entry
6371    point coincides with its global entry point.  */
6372
6373 static bfd_boolean
6374 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6375 {
6376   return (h != NULL
6377           && h->type == STT_FUNC
6378           && h->root.type == bfd_link_hash_defined
6379           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6380           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6381           && is_ppc64_elf (h->root.u.def.section->owner)
6382           && abiversion (h->root.u.def.section->owner) >= 2);
6383 }
6384
6385 /* Return true if symbol is defined in a regular object file.  */
6386
6387 static bfd_boolean
6388 is_static_defined (struct elf_link_hash_entry *h)
6389 {
6390   return ((h->root.type == bfd_link_hash_defined
6391            || h->root.type == bfd_link_hash_defweak)
6392           && h->root.u.def.section != NULL
6393           && h->root.u.def.section->output_section != NULL);
6394 }
6395
6396 /* If FDH is a function descriptor symbol, return the associated code
6397    entry symbol if it is defined.  Return NULL otherwise.  */
6398
6399 static struct ppc_link_hash_entry *
6400 defined_code_entry (struct ppc_link_hash_entry *fdh)
6401 {
6402   if (fdh->is_func_descriptor)
6403     {
6404       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6405       if (fh->elf.root.type == bfd_link_hash_defined
6406           || fh->elf.root.type == bfd_link_hash_defweak)
6407         return fh;
6408     }
6409   return NULL;
6410 }
6411
6412 /* If FH is a function code entry symbol, return the associated
6413    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6414
6415 static struct ppc_link_hash_entry *
6416 defined_func_desc (struct ppc_link_hash_entry *fh)
6417 {
6418   if (fh->oh != NULL
6419       && fh->oh->is_func_descriptor)
6420     {
6421       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6422       if (fdh->elf.root.type == bfd_link_hash_defined
6423           || fdh->elf.root.type == bfd_link_hash_defweak)
6424         return fdh;
6425     }
6426   return NULL;
6427 }
6428
6429 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6430
6431 /* Garbage collect sections, after first dealing with dot-symbols.  */
6432
6433 static bfd_boolean
6434 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6435 {
6436   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6437
6438   if (htab != NULL && htab->need_func_desc_adj)
6439     {
6440       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6441       htab->need_func_desc_adj = 0;
6442     }
6443   return bfd_elf_gc_sections (abfd, info);
6444 }
6445
6446 /* Mark all our entry sym sections, both opd and code section.  */
6447
6448 static void
6449 ppc64_elf_gc_keep (struct bfd_link_info *info)
6450 {
6451   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6452   struct bfd_sym_chain *sym;
6453
6454   if (htab == NULL)
6455     return;
6456
6457   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6458     {
6459       struct ppc_link_hash_entry *eh, *fh;
6460       asection *sec;
6461
6462       eh = (struct ppc_link_hash_entry *)
6463         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6464       if (eh == NULL)
6465         continue;
6466       if (eh->elf.root.type != bfd_link_hash_defined
6467           && eh->elf.root.type != bfd_link_hash_defweak)
6468         continue;
6469
6470       fh = defined_code_entry (eh);
6471       if (fh != NULL)
6472         {
6473           sec = fh->elf.root.u.def.section;
6474           sec->flags |= SEC_KEEP;
6475         }
6476       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6477                && opd_entry_value (eh->elf.root.u.def.section,
6478                                    eh->elf.root.u.def.value,
6479                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6480         sec->flags |= SEC_KEEP;
6481
6482       sec = eh->elf.root.u.def.section;
6483       sec->flags |= SEC_KEEP;
6484     }
6485 }
6486
6487 /* Mark sections containing dynamically referenced symbols.  When
6488    building shared libraries, we must assume that any visible symbol is
6489    referenced.  */
6490
6491 static bfd_boolean
6492 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6493 {
6494   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6495   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6496   struct ppc_link_hash_entry *fdh;
6497   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6498
6499   /* Dynamic linking info is on the func descriptor sym.  */
6500   fdh = defined_func_desc (eh);
6501   if (fdh != NULL)
6502     eh = fdh;
6503
6504   if ((eh->elf.root.type == bfd_link_hash_defined
6505        || eh->elf.root.type == bfd_link_hash_defweak)
6506       && (eh->elf.ref_dynamic
6507           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6508               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6509               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6510               && (!bfd_link_executable (info)
6511                   || info->gc_keep_exported
6512                   || info->export_dynamic
6513                   || (eh->elf.dynamic
6514                       && d != NULL
6515                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6516               && (eh->elf.versioned >= versioned
6517                   || !bfd_hide_sym_by_version (info->version_info,
6518                                                eh->elf.root.root.string)))))
6519     {
6520       asection *code_sec;
6521       struct ppc_link_hash_entry *fh;
6522
6523       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6524
6525       /* Function descriptor syms cause the associated
6526          function code sym section to be marked.  */
6527       fh = defined_code_entry (eh);
6528       if (fh != NULL)
6529         {
6530           code_sec = fh->elf.root.u.def.section;
6531           code_sec->flags |= SEC_KEEP;
6532         }
6533       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6534                && opd_entry_value (eh->elf.root.u.def.section,
6535                                    eh->elf.root.u.def.value,
6536                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6537         code_sec->flags |= SEC_KEEP;
6538     }
6539
6540   return TRUE;
6541 }
6542
6543 /* Return the section that should be marked against GC for a given
6544    relocation.  */
6545
6546 static asection *
6547 ppc64_elf_gc_mark_hook (asection *sec,
6548                         struct bfd_link_info *info,
6549                         Elf_Internal_Rela *rel,
6550                         struct elf_link_hash_entry *h,
6551                         Elf_Internal_Sym *sym)
6552 {
6553   asection *rsec;
6554
6555   /* Syms return NULL if we're marking .opd, so we avoid marking all
6556      function sections, as all functions are referenced in .opd.  */
6557   rsec = NULL;
6558   if (get_opd_info (sec) != NULL)
6559     return rsec;
6560
6561   if (h != NULL)
6562     {
6563       enum elf_ppc64_reloc_type r_type;
6564       struct ppc_link_hash_entry *eh, *fh, *fdh;
6565
6566       r_type = ELF64_R_TYPE (rel->r_info);
6567       switch (r_type)
6568         {
6569         case R_PPC64_GNU_VTINHERIT:
6570         case R_PPC64_GNU_VTENTRY:
6571           break;
6572
6573         default:
6574           switch (h->root.type)
6575             {
6576             case bfd_link_hash_defined:
6577             case bfd_link_hash_defweak:
6578               eh = (struct ppc_link_hash_entry *) h;
6579               fdh = defined_func_desc (eh);
6580               if (fdh != NULL)
6581                 {
6582                   /* -mcall-aixdesc code references the dot-symbol on
6583                      a call reloc.  Mark the function descriptor too
6584                      against garbage collection.  */
6585                   fdh->elf.mark = 1;
6586                   if (fdh->elf.u.weakdef != NULL)
6587                     fdh->elf.u.weakdef->mark = 1;
6588                   eh = fdh;
6589                 }
6590
6591               /* Function descriptor syms cause the associated
6592                  function code sym section to be marked.  */
6593               fh = defined_code_entry (eh);
6594               if (fh != NULL)
6595                 {
6596                   /* They also mark their opd section.  */
6597                   eh->elf.root.u.def.section->gc_mark = 1;
6598
6599                   rsec = fh->elf.root.u.def.section;
6600                 }
6601               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6602                        && opd_entry_value (eh->elf.root.u.def.section,
6603                                            eh->elf.root.u.def.value,
6604                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6605                 eh->elf.root.u.def.section->gc_mark = 1;
6606               else
6607                 rsec = h->root.u.def.section;
6608               break;
6609
6610             case bfd_link_hash_common:
6611               rsec = h->root.u.c.p->section;
6612               break;
6613
6614             default:
6615               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6616             }
6617         }
6618     }
6619   else
6620     {
6621       struct _opd_sec_data *opd;
6622
6623       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6624       opd = get_opd_info (rsec);
6625       if (opd != NULL && opd->func_sec != NULL)
6626         {
6627           rsec->gc_mark = 1;
6628
6629           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6630         }
6631     }
6632
6633   return rsec;
6634 }
6635
6636 /* Update the .got, .plt. and dynamic reloc reference counts for the
6637    section being removed.  */
6638
6639 static bfd_boolean
6640 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6641                          asection *sec, const Elf_Internal_Rela *relocs)
6642 {
6643   struct ppc_link_hash_table *htab;
6644   Elf_Internal_Shdr *symtab_hdr;
6645   struct elf_link_hash_entry **sym_hashes;
6646   struct got_entry **local_got_ents;
6647   const Elf_Internal_Rela *rel, *relend;
6648
6649   if (bfd_link_relocatable (info))
6650     return TRUE;
6651
6652   if ((sec->flags & SEC_ALLOC) == 0)
6653     return TRUE;
6654
6655   elf_section_data (sec)->local_dynrel = NULL;
6656
6657   htab = ppc_hash_table (info);
6658   if (htab == NULL)
6659     return FALSE;
6660
6661   symtab_hdr = &elf_symtab_hdr (abfd);
6662   sym_hashes = elf_sym_hashes (abfd);
6663   local_got_ents = elf_local_got_ents (abfd);
6664
6665   relend = relocs + sec->reloc_count;
6666   for (rel = relocs; rel < relend; rel++)
6667     {
6668       unsigned long r_symndx;
6669       enum elf_ppc64_reloc_type r_type;
6670       struct elf_link_hash_entry *h = NULL;
6671       struct plt_entry **plt_list = NULL;
6672       unsigned char tls_type = 0;
6673
6674       r_symndx = ELF64_R_SYM (rel->r_info);
6675       r_type = ELF64_R_TYPE (rel->r_info);
6676       if (r_symndx >= symtab_hdr->sh_info)
6677         {
6678           struct ppc_link_hash_entry *eh;
6679           struct elf_dyn_relocs **pp;
6680           struct elf_dyn_relocs *p;
6681
6682           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6683           h = elf_follow_link (h);
6684           eh = (struct ppc_link_hash_entry *) h;
6685
6686           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6687             if (p->sec == sec)
6688               {
6689                 /* Everything must go for SEC.  */
6690                 *pp = p->next;
6691                 break;
6692               }
6693         }
6694
6695       switch (r_type)
6696         {
6697         case R_PPC64_GOT_TLSLD16:
6698         case R_PPC64_GOT_TLSLD16_LO:
6699         case R_PPC64_GOT_TLSLD16_HI:
6700         case R_PPC64_GOT_TLSLD16_HA:
6701           tls_type = TLS_TLS | TLS_LD;
6702           goto dogot;
6703
6704         case R_PPC64_GOT_TLSGD16:
6705         case R_PPC64_GOT_TLSGD16_LO:
6706         case R_PPC64_GOT_TLSGD16_HI:
6707         case R_PPC64_GOT_TLSGD16_HA:
6708           tls_type = TLS_TLS | TLS_GD;
6709           goto dogot;
6710
6711         case R_PPC64_GOT_TPREL16_DS:
6712         case R_PPC64_GOT_TPREL16_LO_DS:
6713         case R_PPC64_GOT_TPREL16_HI:
6714         case R_PPC64_GOT_TPREL16_HA:
6715           tls_type = TLS_TLS | TLS_TPREL;
6716           goto dogot;
6717
6718         case R_PPC64_GOT_DTPREL16_DS:
6719         case R_PPC64_GOT_DTPREL16_LO_DS:
6720         case R_PPC64_GOT_DTPREL16_HI:
6721         case R_PPC64_GOT_DTPREL16_HA:
6722           tls_type = TLS_TLS | TLS_DTPREL;
6723           goto dogot;
6724
6725         case R_PPC64_GOT16:
6726         case R_PPC64_GOT16_DS:
6727         case R_PPC64_GOT16_HA:
6728         case R_PPC64_GOT16_HI:
6729         case R_PPC64_GOT16_LO:
6730         case R_PPC64_GOT16_LO_DS:
6731         dogot:
6732           {
6733             struct got_entry *ent;
6734
6735             if (h != NULL)
6736               ent = h->got.glist;
6737             else
6738               ent = local_got_ents[r_symndx];
6739
6740             for (; ent != NULL; ent = ent->next)
6741               if (ent->addend == rel->r_addend
6742                   && ent->owner == abfd
6743                   && ent->tls_type == tls_type)
6744                 break;
6745             if (ent == NULL)
6746               abort ();
6747             if (ent->got.refcount > 0)
6748               ent->got.refcount -= 1;
6749           }
6750           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6751             plt_list = &h->plt.plist;
6752           break;
6753
6754         case R_PPC64_PLT16_HA:
6755         case R_PPC64_PLT16_HI:
6756         case R_PPC64_PLT16_LO:
6757         case R_PPC64_PLT32:
6758         case R_PPC64_PLT64:
6759         case R_PPC64_REL14:
6760         case R_PPC64_REL14_BRNTAKEN:
6761         case R_PPC64_REL14_BRTAKEN:
6762         case R_PPC64_REL24:
6763           if (h != NULL)
6764             plt_list = &h->plt.plist;
6765           else if (local_got_ents != NULL)
6766             {
6767               struct plt_entry **local_plt = (struct plt_entry **)
6768                 (local_got_ents + symtab_hdr->sh_info);
6769               unsigned char *local_got_tls_masks = (unsigned char *)
6770                 (local_plt + symtab_hdr->sh_info);
6771               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6772                 plt_list = local_plt + r_symndx;
6773             }
6774           break;
6775
6776         case R_PPC64_ADDR64:
6777         case R_PPC64_ADDR16:
6778         case R_PPC64_ADDR16_DS:
6779         case R_PPC64_ADDR16_HA:
6780         case R_PPC64_ADDR16_HI:
6781         case R_PPC64_ADDR16_HIGH:
6782         case R_PPC64_ADDR16_HIGHA:
6783         case R_PPC64_ADDR16_HIGHER:
6784         case R_PPC64_ADDR16_HIGHERA:
6785         case R_PPC64_ADDR16_HIGHEST:
6786         case R_PPC64_ADDR16_HIGHESTA:
6787         case R_PPC64_ADDR16_LO:
6788         case R_PPC64_ADDR16_LO_DS:
6789           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6790               && rel->r_addend == 0)
6791             plt_list = &h->plt.plist;
6792           break;
6793
6794         default:
6795           break;
6796         }
6797       if (plt_list != NULL)
6798         {
6799           struct plt_entry *ent;
6800
6801           for (ent = *plt_list; ent != NULL; ent = ent->next)
6802             if (ent->addend == rel->r_addend)
6803               break;
6804           if (ent != NULL && ent->plt.refcount > 0)
6805             ent->plt.refcount -= 1;
6806         }
6807     }
6808   return TRUE;
6809 }
6810
6811 /* The maximum size of .sfpr.  */
6812 #define SFPR_MAX (218*4)
6813
6814 struct sfpr_def_parms
6815 {
6816   const char name[12];
6817   unsigned char lo, hi;
6818   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6819   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6820 };
6821
6822 /* Auto-generate _save*, _rest* functions in .sfpr.
6823    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6824    instead.  */
6825
6826 static bfd_boolean
6827 sfpr_define (struct bfd_link_info *info,
6828              const struct sfpr_def_parms *parm,
6829              asection *stub_sec)
6830 {
6831   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6832   unsigned int i;
6833   size_t len = strlen (parm->name);
6834   bfd_boolean writing = FALSE;
6835   char sym[16];
6836
6837   if (htab == NULL)
6838     return FALSE;
6839
6840   memcpy (sym, parm->name, len);
6841   sym[len + 2] = 0;
6842
6843   for (i = parm->lo; i <= parm->hi; i++)
6844     {
6845       struct ppc_link_hash_entry *h;
6846
6847       sym[len + 0] = i / 10 + '0';
6848       sym[len + 1] = i % 10 + '0';
6849       h = (struct ppc_link_hash_entry *)
6850         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6851       if (stub_sec != NULL)
6852         {
6853           if (h != NULL
6854               && h->elf.root.type == bfd_link_hash_defined
6855               && h->elf.root.u.def.section == htab->sfpr)
6856             {
6857               struct elf_link_hash_entry *s;
6858               char buf[32];
6859               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6860               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6861               if (s == NULL)
6862                 return FALSE;
6863               if (s->root.type == bfd_link_hash_new
6864                   || (s->root.type = bfd_link_hash_defined
6865                       && s->root.u.def.section == stub_sec))
6866                 {
6867                   s->root.type = bfd_link_hash_defined;
6868                   s->root.u.def.section = stub_sec;
6869                   s->root.u.def.value = (stub_sec->size
6870                                          + h->elf.root.u.def.value);
6871                   s->ref_regular = 1;
6872                   s->def_regular = 1;
6873                   s->ref_regular_nonweak = 1;
6874                   s->forced_local = 1;
6875                   s->non_elf = 0;
6876                   s->root.linker_def = 1;
6877                 }
6878             }
6879           continue;
6880         }
6881       if (h != NULL)
6882         {
6883           h->save_res = 1;
6884           if (!h->elf.def_regular)
6885             {
6886               h->elf.root.type = bfd_link_hash_defined;
6887               h->elf.root.u.def.section = htab->sfpr;
6888               h->elf.root.u.def.value = htab->sfpr->size;
6889               h->elf.type = STT_FUNC;
6890               h->elf.def_regular = 1;
6891               h->elf.non_elf = 0;
6892               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6893               writing = TRUE;
6894               if (htab->sfpr->contents == NULL)
6895                 {
6896                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6897                   if (htab->sfpr->contents == NULL)
6898                     return FALSE;
6899                 }
6900             }
6901         }
6902       if (writing)
6903         {
6904           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6905           if (i != parm->hi)
6906             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6907           else
6908             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6909           htab->sfpr->size = p - htab->sfpr->contents;
6910         }
6911     }
6912
6913   return TRUE;
6914 }
6915
6916 static bfd_byte *
6917 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6918 {
6919   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6920   return p + 4;
6921 }
6922
6923 static bfd_byte *
6924 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6925 {
6926   p = savegpr0 (abfd, p, r);
6927   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6928   p = p + 4;
6929   bfd_put_32 (abfd, BLR, p);
6930   return p + 4;
6931 }
6932
6933 static bfd_byte *
6934 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6935 {
6936   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6937   return p + 4;
6938 }
6939
6940 static bfd_byte *
6941 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6942 {
6943   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6944   p = p + 4;
6945   p = restgpr0 (abfd, p, r);
6946   bfd_put_32 (abfd, MTLR_R0, p);
6947   p = p + 4;
6948   if (r == 29)
6949     {
6950       p = restgpr0 (abfd, p, 30);
6951       p = restgpr0 (abfd, p, 31);
6952     }
6953   bfd_put_32 (abfd, BLR, p);
6954   return p + 4;
6955 }
6956
6957 static bfd_byte *
6958 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6959 {
6960   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6961   return p + 4;
6962 }
6963
6964 static bfd_byte *
6965 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6966 {
6967   p = savegpr1 (abfd, p, r);
6968   bfd_put_32 (abfd, BLR, p);
6969   return p + 4;
6970 }
6971
6972 static bfd_byte *
6973 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6974 {
6975   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6976   return p + 4;
6977 }
6978
6979 static bfd_byte *
6980 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6981 {
6982   p = restgpr1 (abfd, p, r);
6983   bfd_put_32 (abfd, BLR, p);
6984   return p + 4;
6985 }
6986
6987 static bfd_byte *
6988 savefpr (bfd *abfd, bfd_byte *p, int r)
6989 {
6990   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6991   return p + 4;
6992 }
6993
6994 static bfd_byte *
6995 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6996 {
6997   p = savefpr (abfd, p, r);
6998   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6999   p = p + 4;
7000   bfd_put_32 (abfd, BLR, p);
7001   return p + 4;
7002 }
7003
7004 static bfd_byte *
7005 restfpr (bfd *abfd, bfd_byte *p, int r)
7006 {
7007   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7008   return p + 4;
7009 }
7010
7011 static bfd_byte *
7012 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
7013 {
7014   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
7015   p = p + 4;
7016   p = restfpr (abfd, p, r);
7017   bfd_put_32 (abfd, MTLR_R0, p);
7018   p = p + 4;
7019   if (r == 29)
7020     {
7021       p = restfpr (abfd, p, 30);
7022       p = restfpr (abfd, p, 31);
7023     }
7024   bfd_put_32 (abfd, BLR, p);
7025   return p + 4;
7026 }
7027
7028 static bfd_byte *
7029 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7030 {
7031   p = savefpr (abfd, p, r);
7032   bfd_put_32 (abfd, BLR, p);
7033   return p + 4;
7034 }
7035
7036 static bfd_byte *
7037 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7038 {
7039   p = restfpr (abfd, p, r);
7040   bfd_put_32 (abfd, BLR, p);
7041   return p + 4;
7042 }
7043
7044 static bfd_byte *
7045 savevr (bfd *abfd, bfd_byte *p, int r)
7046 {
7047   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7048   p = p + 4;
7049   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7050   return p + 4;
7051 }
7052
7053 static bfd_byte *
7054 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7055 {
7056   p = savevr (abfd, p, r);
7057   bfd_put_32 (abfd, BLR, p);
7058   return p + 4;
7059 }
7060
7061 static bfd_byte *
7062 restvr (bfd *abfd, bfd_byte *p, int r)
7063 {
7064   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7065   p = p + 4;
7066   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7067   return p + 4;
7068 }
7069
7070 static bfd_byte *
7071 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7072 {
7073   p = restvr (abfd, p, r);
7074   bfd_put_32 (abfd, BLR, p);
7075   return p + 4;
7076 }
7077
7078 /* Called via elf_link_hash_traverse to transfer dynamic linking
7079    information on function code symbol entries to their corresponding
7080    function descriptor symbol entries.  */
7081
7082 static bfd_boolean
7083 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7084 {
7085   struct bfd_link_info *info;
7086   struct ppc_link_hash_table *htab;
7087   struct ppc_link_hash_entry *fh;
7088   struct ppc_link_hash_entry *fdh;
7089   bfd_boolean force_local;
7090
7091   fh = (struct ppc_link_hash_entry *) h;
7092   if (fh->elf.root.type == bfd_link_hash_indirect)
7093     return TRUE;
7094
7095   if (!fh->is_func)
7096     return TRUE;
7097
7098   if (fh->elf.root.root.string[0] != '.'
7099       || fh->elf.root.root.string[1] == '\0')
7100     return TRUE;
7101
7102   info = inf;
7103   htab = ppc_hash_table (info);
7104   if (htab == NULL)
7105     return FALSE;
7106
7107   /* Find the corresponding function descriptor symbol.  */
7108   fdh = lookup_fdh (fh, htab);
7109
7110   /* Resolve undefined references to dot-symbols as the value
7111      in the function descriptor, if we have one in a regular object.
7112      This is to satisfy cases like ".quad .foo".  Calls to functions
7113      in dynamic objects are handled elsewhere.  */
7114   if ((fh->elf.root.type == bfd_link_hash_undefined
7115        || fh->elf.root.type == bfd_link_hash_undefweak)
7116       && (fdh->elf.root.type == bfd_link_hash_defined
7117           || fdh->elf.root.type == bfd_link_hash_defweak)
7118       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7119       && opd_entry_value (fdh->elf.root.u.def.section,
7120                           fdh->elf.root.u.def.value,
7121                           &fh->elf.root.u.def.section,
7122                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7123     {
7124       fh->elf.root.type = fdh->elf.root.type;
7125       fh->elf.forced_local = 1;
7126       fh->elf.def_regular = fdh->elf.def_regular;
7127       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7128     }
7129
7130   if (!fh->elf.dynamic)
7131     {
7132       struct plt_entry *ent;
7133
7134       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7135         if (ent->plt.refcount > 0)
7136           break;
7137       if (ent == NULL)
7138         return TRUE;
7139     }
7140
7141   /* Create a descriptor as undefined if necessary.  */
7142   if (fdh == NULL
7143       && !bfd_link_executable (info)
7144       && (fh->elf.root.type == bfd_link_hash_undefined
7145           || fh->elf.root.type == bfd_link_hash_undefweak))
7146     {
7147       fdh = make_fdh (info, fh);
7148       if (fdh == NULL)
7149         return FALSE;
7150     }
7151
7152   /* We can't support overriding of symbols on a fake descriptor.  */
7153   if (fdh != NULL
7154       && fdh->fake
7155       && (fh->elf.root.type == bfd_link_hash_defined
7156           || fh->elf.root.type == bfd_link_hash_defweak))
7157     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7158
7159   /* Transfer dynamic linking information to the function descriptor.  */
7160   if (fdh != NULL)
7161     {
7162       fdh->elf.ref_regular |= fh->elf.ref_regular;
7163       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7164       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7165       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7166       fdh->elf.dynamic |= fh->elf.dynamic;
7167       fdh->elf.needs_plt |= (fh->elf.needs_plt
7168                              || fh->elf.type == STT_FUNC
7169                              || fh->elf.type == STT_GNU_IFUNC);
7170       move_plt_plist (fh, fdh);
7171
7172       if (!fdh->elf.forced_local
7173           && fh->elf.dynindx != -1)
7174         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7175           return FALSE;
7176     }
7177
7178   /* Now that the info is on the function descriptor, clear the
7179      function code sym info.  Any function code syms for which we
7180      don't have a definition in a regular file, we force local.
7181      This prevents a shared library from exporting syms that have
7182      been imported from another library.  Function code syms that
7183      are really in the library we must leave global to prevent the
7184      linker dragging in a definition from a static library.  */
7185   force_local = (!fh->elf.def_regular
7186                  || fdh == NULL
7187                  || !fdh->elf.def_regular
7188                  || fdh->elf.forced_local);
7189   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7190
7191   return TRUE;
7192 }
7193
7194 static const struct sfpr_def_parms save_res_funcs[] =
7195   {
7196     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7197     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7198     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7199     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7200     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7201     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7202     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7203     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7204     { "._savef", 14, 31, savefpr, savefpr1_tail },
7205     { "._restf", 14, 31, restfpr, restfpr1_tail },
7206     { "_savevr_", 20, 31, savevr, savevr_tail },
7207     { "_restvr_", 20, 31, restvr, restvr_tail }
7208   };
7209
7210 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7211    this hook to a) provide some gcc support functions, and b) transfer
7212    dynamic linking information gathered so far on function code symbol
7213    entries, to their corresponding function descriptor symbol entries.  */
7214
7215 static bfd_boolean
7216 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7217                             struct bfd_link_info *info)
7218 {
7219   struct ppc_link_hash_table *htab;
7220
7221   htab = ppc_hash_table (info);
7222   if (htab == NULL)
7223     return FALSE;
7224
7225   /* Provide any missing _save* and _rest* functions.  */
7226   if (htab->sfpr != NULL)
7227     {
7228       unsigned int i;
7229
7230       htab->sfpr->size = 0;
7231       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7232         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7233           return FALSE;
7234       if (htab->sfpr->size == 0)
7235         htab->sfpr->flags |= SEC_EXCLUDE;
7236     }
7237
7238   if (bfd_link_relocatable (info))
7239     return TRUE;
7240
7241   if (htab->elf.hgot != NULL)
7242     {
7243       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7244       /* Make .TOC. defined so as to prevent it being made dynamic.
7245          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7246       if (!htab->elf.hgot->def_regular
7247           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7248         {
7249           htab->elf.hgot->root.type = bfd_link_hash_defined;
7250           htab->elf.hgot->root.u.def.value = 0;
7251           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7252           htab->elf.hgot->def_regular = 1;
7253           htab->elf.hgot->root.linker_def = 1;
7254         }
7255       htab->elf.hgot->type = STT_OBJECT;
7256       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7257                                | STV_HIDDEN);
7258     }
7259
7260   if (htab->need_func_desc_adj)
7261     {
7262       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7263       htab->need_func_desc_adj = 0;
7264     }
7265
7266   return TRUE;
7267 }
7268
7269 /* Return true if we have dynamic relocs against H that apply to
7270    read-only sections.  */
7271
7272 static bfd_boolean
7273 readonly_dynrelocs (struct elf_link_hash_entry *h)
7274 {
7275   struct ppc_link_hash_entry *eh;
7276   struct elf_dyn_relocs *p;
7277
7278   eh = (struct ppc_link_hash_entry *) h;
7279   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7280     {
7281       asection *s = p->sec->output_section;
7282
7283       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7284         return TRUE;
7285     }
7286   return FALSE;
7287 }
7288
7289 /* Return true if we have dynamic relocs against H or any of its weak
7290    aliases, that apply to read-only sections.  */
7291
7292 static bfd_boolean
7293 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7294 {
7295   struct ppc_link_hash_entry *eh;
7296
7297   eh = (struct ppc_link_hash_entry *) h;
7298   do
7299     {
7300       if (readonly_dynrelocs (&eh->elf))
7301         return TRUE;
7302       eh = eh->weakref;
7303     } while (eh != NULL && &eh->elf != h);
7304
7305   return FALSE;
7306 }
7307
7308 /* Return whether EH has pc-relative dynamic relocs.  */
7309
7310 static bfd_boolean
7311 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7312 {
7313   struct elf_dyn_relocs *p;
7314
7315   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7316     if (p->pc_count != 0)
7317       return TRUE;
7318   return FALSE;
7319 }
7320
7321 /* Return true if a global entry stub will be created for H.  Valid
7322    for ELFv2 before plt entries have been allocated.  */
7323
7324 static bfd_boolean
7325 global_entry_stub (struct elf_link_hash_entry *h)
7326 {
7327   struct plt_entry *pent;
7328
7329   if (!h->pointer_equality_needed
7330       || h->def_regular)
7331     return FALSE;
7332
7333   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7334     if (pent->plt.refcount > 0
7335         && pent->addend == 0)
7336       return TRUE;
7337
7338   return FALSE;
7339 }
7340
7341 /* Adjust a symbol defined by a dynamic object and referenced by a
7342    regular object.  The current definition is in some section of the
7343    dynamic object, but we're not including those sections.  We have to
7344    change the definition to something the rest of the link can
7345    understand.  */
7346
7347 static bfd_boolean
7348 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7349                                  struct elf_link_hash_entry *h)
7350 {
7351   struct ppc_link_hash_table *htab;
7352   asection *s, *srel;
7353
7354   htab = ppc_hash_table (info);
7355   if (htab == NULL)
7356     return FALSE;
7357
7358   /* Deal with function syms.  */
7359   if (h->type == STT_FUNC
7360       || h->type == STT_GNU_IFUNC
7361       || h->needs_plt)
7362     {
7363       /* Clear procedure linkage table information for any symbol that
7364          won't need a .plt entry.  */
7365       struct plt_entry *ent;
7366       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7367         if (ent->plt.refcount > 0)
7368           break;
7369       if (ent == NULL
7370           || (h->type != STT_GNU_IFUNC
7371               && (SYMBOL_CALLS_LOCAL (info, h)
7372                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7373           || ((struct ppc_link_hash_entry *) h)->save_res)
7374         {
7375           h->plt.plist = NULL;
7376           h->needs_plt = 0;
7377           h->pointer_equality_needed = 0;
7378         }
7379       else if (abiversion (info->output_bfd) >= 2)
7380         {
7381           /* Taking a function's address in a read/write section
7382              doesn't require us to define the function symbol in the
7383              executable on a global entry stub.  A dynamic reloc can
7384              be used instead.  The reason we prefer a few more dynamic
7385              relocs is that calling via a global entry stub costs a
7386              few more instructions, and pointer_equality_needed causes
7387              extra work in ld.so when resolving these symbols.  */
7388           if (global_entry_stub (h)
7389               && !alias_readonly_dynrelocs (h))
7390             {
7391               h->pointer_equality_needed = 0;
7392               /* After adjust_dynamic_symbol, non_got_ref set in
7393                  the non-pic case means that dyn_relocs for this
7394                  symbol should be discarded.  */
7395               h->non_got_ref = 0;
7396             }
7397
7398           /* If making a plt entry, then we don't need copy relocs.  */
7399           return TRUE;
7400         }
7401     }
7402   else
7403     h->plt.plist = NULL;
7404
7405   /* If this is a weak symbol, and there is a real definition, the
7406      processor independent code will have arranged for us to see the
7407      real definition first, and we can just use the same value.  */
7408   if (h->u.weakdef != NULL)
7409     {
7410       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7411                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7412       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7413       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7414       if (ELIMINATE_COPY_RELOCS)
7415         h->non_got_ref = h->u.weakdef->non_got_ref;
7416       return TRUE;
7417     }
7418
7419   /* If we are creating a shared library, we must presume that the
7420      only references to the symbol are via the global offset table.
7421      For such cases we need not do anything here; the relocations will
7422      be handled correctly by relocate_section.  */
7423   if (bfd_link_pic (info))
7424     return TRUE;
7425
7426   /* If there are no references to this symbol that do not use the
7427      GOT, we don't need to generate a copy reloc.  */
7428   if (!h->non_got_ref)
7429     return TRUE;
7430
7431   /* Don't generate a copy reloc for symbols defined in the executable.  */
7432   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7433
7434       /* If -z nocopyreloc was given, don't generate them either.  */
7435       || info->nocopyreloc
7436
7437       /* If we didn't find any dynamic relocs in read-only sections, then
7438          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7439       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7440
7441       /* Protected variables do not work with .dynbss.  The copy in
7442          .dynbss won't be used by the shared library with the protected
7443          definition for the variable.  Text relocations are preferable
7444          to an incorrect program.  */
7445       || h->protected_def)
7446     {
7447       h->non_got_ref = 0;
7448       return TRUE;
7449     }
7450
7451   if (h->plt.plist != NULL)
7452     {
7453       /* We should never get here, but unfortunately there are versions
7454          of gcc out there that improperly (for this ABI) put initialized
7455          function pointers, vtable refs and suchlike in read-only
7456          sections.  Allow them to proceed, but warn that this might
7457          break at runtime.  */
7458       info->callbacks->einfo
7459         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7460            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7461          h->root.root.string);
7462     }
7463
7464   /* This is a reference to a symbol defined by a dynamic object which
7465      is not a function.  */
7466
7467   /* We must allocate the symbol in our .dynbss section, which will
7468      become part of the .bss section of the executable.  There will be
7469      an entry for this symbol in the .dynsym section.  The dynamic
7470      object will contain position independent code, so all references
7471      from the dynamic object to this symbol will go through the global
7472      offset table.  The dynamic linker will use the .dynsym entry to
7473      determine the address it must put in the global offset table, so
7474      both the dynamic object and the regular object will refer to the
7475      same memory location for the variable.  */
7476
7477   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7478      to copy the initial value out of the dynamic object and into the
7479      runtime process image.  We need to remember the offset into the
7480      .rela.bss section we are going to use.  */
7481   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7482     {
7483       s = htab->elf.sdynrelro;
7484       srel = htab->elf.sreldynrelro;
7485     }
7486   else
7487     {
7488       s = htab->elf.sdynbss;
7489       srel = htab->elf.srelbss;
7490     }
7491   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7492     {
7493       srel->size += sizeof (Elf64_External_Rela);
7494       h->needs_copy = 1;
7495     }
7496
7497   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7498 }
7499
7500 /* If given a function descriptor symbol, hide both the function code
7501    sym and the descriptor.  */
7502 static void
7503 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7504                        struct elf_link_hash_entry *h,
7505                        bfd_boolean force_local)
7506 {
7507   struct ppc_link_hash_entry *eh;
7508   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7509
7510   eh = (struct ppc_link_hash_entry *) h;
7511   if (eh->is_func_descriptor)
7512     {
7513       struct ppc_link_hash_entry *fh = eh->oh;
7514
7515       if (fh == NULL)
7516         {
7517           const char *p, *q;
7518           struct elf_link_hash_table *htab = elf_hash_table (info);
7519           char save;
7520
7521           /* We aren't supposed to use alloca in BFD because on
7522              systems which do not have alloca the version in libiberty
7523              calls xmalloc, which might cause the program to crash
7524              when it runs out of memory.  This function doesn't have a
7525              return status, so there's no way to gracefully return an
7526              error.  So cheat.  We know that string[-1] can be safely
7527              accessed;  It's either a string in an ELF string table,
7528              or allocated in an objalloc structure.  */
7529
7530           p = eh->elf.root.root.string - 1;
7531           save = *p;
7532           *(char *) p = '.';
7533           fh = (struct ppc_link_hash_entry *)
7534             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7535           *(char *) p = save;
7536
7537           /* Unfortunately, if it so happens that the string we were
7538              looking for was allocated immediately before this string,
7539              then we overwrote the string terminator.  That's the only
7540              reason the lookup should fail.  */
7541           if (fh == NULL)
7542             {
7543               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7544               while (q >= eh->elf.root.root.string && *q == *p)
7545                 --q, --p;
7546               if (q < eh->elf.root.root.string && *p == '.')
7547                 fh = (struct ppc_link_hash_entry *)
7548                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7549             }
7550           if (fh != NULL)
7551             {
7552               eh->oh = fh;
7553               fh->oh = eh;
7554             }
7555         }
7556       if (fh != NULL)
7557         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7558     }
7559 }
7560
7561 static bfd_boolean
7562 get_sym_h (struct elf_link_hash_entry **hp,
7563            Elf_Internal_Sym **symp,
7564            asection **symsecp,
7565            unsigned char **tls_maskp,
7566            Elf_Internal_Sym **locsymsp,
7567            unsigned long r_symndx,
7568            bfd *ibfd)
7569 {
7570   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7571
7572   if (r_symndx >= symtab_hdr->sh_info)
7573     {
7574       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7575       struct elf_link_hash_entry *h;
7576
7577       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7578       h = elf_follow_link (h);
7579
7580       if (hp != NULL)
7581         *hp = h;
7582
7583       if (symp != NULL)
7584         *symp = NULL;
7585
7586       if (symsecp != NULL)
7587         {
7588           asection *symsec = NULL;
7589           if (h->root.type == bfd_link_hash_defined
7590               || h->root.type == bfd_link_hash_defweak)
7591             symsec = h->root.u.def.section;
7592           *symsecp = symsec;
7593         }
7594
7595       if (tls_maskp != NULL)
7596         {
7597           struct ppc_link_hash_entry *eh;
7598
7599           eh = (struct ppc_link_hash_entry *) h;
7600           *tls_maskp = &eh->tls_mask;
7601         }
7602     }
7603   else
7604     {
7605       Elf_Internal_Sym *sym;
7606       Elf_Internal_Sym *locsyms = *locsymsp;
7607
7608       if (locsyms == NULL)
7609         {
7610           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7611           if (locsyms == NULL)
7612             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7613                                             symtab_hdr->sh_info,
7614                                             0, NULL, NULL, NULL);
7615           if (locsyms == NULL)
7616             return FALSE;
7617           *locsymsp = locsyms;
7618         }
7619       sym = locsyms + r_symndx;
7620
7621       if (hp != NULL)
7622         *hp = NULL;
7623
7624       if (symp != NULL)
7625         *symp = sym;
7626
7627       if (symsecp != NULL)
7628         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7629
7630       if (tls_maskp != NULL)
7631         {
7632           struct got_entry **lgot_ents;
7633           unsigned char *tls_mask;
7634
7635           tls_mask = NULL;
7636           lgot_ents = elf_local_got_ents (ibfd);
7637           if (lgot_ents != NULL)
7638             {
7639               struct plt_entry **local_plt = (struct plt_entry **)
7640                 (lgot_ents + symtab_hdr->sh_info);
7641               unsigned char *lgot_masks = (unsigned char *)
7642                 (local_plt + symtab_hdr->sh_info);
7643               tls_mask = &lgot_masks[r_symndx];
7644             }
7645           *tls_maskp = tls_mask;
7646         }
7647     }
7648   return TRUE;
7649 }
7650
7651 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7652    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7653    type suitable for optimization, and 1 otherwise.  */
7654
7655 static int
7656 get_tls_mask (unsigned char **tls_maskp,
7657               unsigned long *toc_symndx,
7658               bfd_vma *toc_addend,
7659               Elf_Internal_Sym **locsymsp,
7660               const Elf_Internal_Rela *rel,
7661               bfd *ibfd)
7662 {
7663   unsigned long r_symndx;
7664   int next_r;
7665   struct elf_link_hash_entry *h;
7666   Elf_Internal_Sym *sym;
7667   asection *sec;
7668   bfd_vma off;
7669
7670   r_symndx = ELF64_R_SYM (rel->r_info);
7671   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7672     return 0;
7673
7674   if ((*tls_maskp != NULL && **tls_maskp != 0)
7675       || sec == NULL
7676       || ppc64_elf_section_data (sec) == NULL
7677       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7678     return 1;
7679
7680   /* Look inside a TOC section too.  */
7681   if (h != NULL)
7682     {
7683       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7684       off = h->root.u.def.value;
7685     }
7686   else
7687     off = sym->st_value;
7688   off += rel->r_addend;
7689   BFD_ASSERT (off % 8 == 0);
7690   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7691   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7692   if (toc_symndx != NULL)
7693     *toc_symndx = r_symndx;
7694   if (toc_addend != NULL)
7695     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7696   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7697     return 0;
7698   if ((h == NULL || is_static_defined (h))
7699       && (next_r == -1 || next_r == -2))
7700     return 1 - next_r;
7701   return 1;
7702 }
7703
7704 /* Find (or create) an entry in the tocsave hash table.  */
7705
7706 static struct tocsave_entry *
7707 tocsave_find (struct ppc_link_hash_table *htab,
7708               enum insert_option insert,
7709               Elf_Internal_Sym **local_syms,
7710               const Elf_Internal_Rela *irela,
7711               bfd *ibfd)
7712 {
7713   unsigned long r_indx;
7714   struct elf_link_hash_entry *h;
7715   Elf_Internal_Sym *sym;
7716   struct tocsave_entry ent, *p;
7717   hashval_t hash;
7718   struct tocsave_entry **slot;
7719
7720   r_indx = ELF64_R_SYM (irela->r_info);
7721   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7722     return NULL;
7723   if (ent.sec == NULL || ent.sec->output_section == NULL)
7724     {
7725       _bfd_error_handler
7726         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7727       return NULL;
7728     }
7729
7730   if (h != NULL)
7731     ent.offset = h->root.u.def.value;
7732   else
7733     ent.offset = sym->st_value;
7734   ent.offset += irela->r_addend;
7735
7736   hash = tocsave_htab_hash (&ent);
7737   slot = ((struct tocsave_entry **)
7738           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7739   if (slot == NULL)
7740     return NULL;
7741
7742   if (*slot == NULL)
7743     {
7744       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7745       if (p == NULL)
7746         return NULL;
7747       *p = ent;
7748       *slot = p;
7749     }
7750   return *slot;
7751 }
7752
7753 /* Adjust all global syms defined in opd sections.  In gcc generated
7754    code for the old ABI, these will already have been done.  */
7755
7756 static bfd_boolean
7757 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7758 {
7759   struct ppc_link_hash_entry *eh;
7760   asection *sym_sec;
7761   struct _opd_sec_data *opd;
7762
7763   if (h->root.type == bfd_link_hash_indirect)
7764     return TRUE;
7765
7766   if (h->root.type != bfd_link_hash_defined
7767       && h->root.type != bfd_link_hash_defweak)
7768     return TRUE;
7769
7770   eh = (struct ppc_link_hash_entry *) h;
7771   if (eh->adjust_done)
7772     return TRUE;
7773
7774   sym_sec = eh->elf.root.u.def.section;
7775   opd = get_opd_info (sym_sec);
7776   if (opd != NULL && opd->adjust != NULL)
7777     {
7778       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7779       if (adjust == -1)
7780         {
7781           /* This entry has been deleted.  */
7782           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7783           if (dsec == NULL)
7784             {
7785               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7786                 if (discarded_section (dsec))
7787                   {
7788                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7789                     break;
7790                   }
7791             }
7792           eh->elf.root.u.def.value = 0;
7793           eh->elf.root.u.def.section = dsec;
7794         }
7795       else
7796         eh->elf.root.u.def.value += adjust;
7797       eh->adjust_done = 1;
7798     }
7799   return TRUE;
7800 }
7801
7802 /* Handles decrementing dynamic reloc counts for the reloc specified by
7803    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7804    have already been determined.  */
7805
7806 static bfd_boolean
7807 dec_dynrel_count (bfd_vma r_info,
7808                   asection *sec,
7809                   struct bfd_link_info *info,
7810                   Elf_Internal_Sym **local_syms,
7811                   struct elf_link_hash_entry *h,
7812                   Elf_Internal_Sym *sym)
7813 {
7814   enum elf_ppc64_reloc_type r_type;
7815   asection *sym_sec = NULL;
7816
7817   /* Can this reloc be dynamic?  This switch, and later tests here
7818      should be kept in sync with the code in check_relocs.  */
7819   r_type = ELF64_R_TYPE (r_info);
7820   switch (r_type)
7821     {
7822     default:
7823       return TRUE;
7824
7825     case R_PPC64_TPREL16:
7826     case R_PPC64_TPREL16_LO:
7827     case R_PPC64_TPREL16_HI:
7828     case R_PPC64_TPREL16_HA:
7829     case R_PPC64_TPREL16_DS:
7830     case R_PPC64_TPREL16_LO_DS:
7831     case R_PPC64_TPREL16_HIGH:
7832     case R_PPC64_TPREL16_HIGHA:
7833     case R_PPC64_TPREL16_HIGHER:
7834     case R_PPC64_TPREL16_HIGHERA:
7835     case R_PPC64_TPREL16_HIGHEST:
7836     case R_PPC64_TPREL16_HIGHESTA:
7837     case R_PPC64_TPREL64:
7838     case R_PPC64_DTPMOD64:
7839     case R_PPC64_DTPREL64:
7840     case R_PPC64_ADDR64:
7841     case R_PPC64_REL30:
7842     case R_PPC64_REL32:
7843     case R_PPC64_REL64:
7844     case R_PPC64_ADDR14:
7845     case R_PPC64_ADDR14_BRNTAKEN:
7846     case R_PPC64_ADDR14_BRTAKEN:
7847     case R_PPC64_ADDR16:
7848     case R_PPC64_ADDR16_DS:
7849     case R_PPC64_ADDR16_HA:
7850     case R_PPC64_ADDR16_HI:
7851     case R_PPC64_ADDR16_HIGH:
7852     case R_PPC64_ADDR16_HIGHA:
7853     case R_PPC64_ADDR16_HIGHER:
7854     case R_PPC64_ADDR16_HIGHERA:
7855     case R_PPC64_ADDR16_HIGHEST:
7856     case R_PPC64_ADDR16_HIGHESTA:
7857     case R_PPC64_ADDR16_LO:
7858     case R_PPC64_ADDR16_LO_DS:
7859     case R_PPC64_ADDR24:
7860     case R_PPC64_ADDR32:
7861     case R_PPC64_UADDR16:
7862     case R_PPC64_UADDR32:
7863     case R_PPC64_UADDR64:
7864     case R_PPC64_TOC:
7865       break;
7866     }
7867
7868   if (local_syms != NULL)
7869     {
7870       unsigned long r_symndx;
7871       bfd *ibfd = sec->owner;
7872
7873       r_symndx = ELF64_R_SYM (r_info);
7874       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7875         return FALSE;
7876     }
7877
7878   if ((bfd_link_pic (info)
7879        && (must_be_dyn_reloc (info, r_type)
7880            || (h != NULL
7881                && (!SYMBOLIC_BIND (info, h)
7882                    || h->root.type == bfd_link_hash_defweak
7883                    || !h->def_regular))))
7884       || (ELIMINATE_COPY_RELOCS
7885           && !bfd_link_pic (info)
7886           && h != NULL
7887           && (h->root.type == bfd_link_hash_defweak
7888               || !h->def_regular)))
7889     ;
7890   else
7891     return TRUE;
7892
7893   if (h != NULL)
7894     {
7895       struct elf_dyn_relocs *p;
7896       struct elf_dyn_relocs **pp;
7897       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7898
7899       /* elf_gc_sweep may have already removed all dyn relocs associated
7900          with local syms for a given section.  Also, symbol flags are
7901          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7902          report a dynreloc miscount.  */
7903       if (*pp == NULL && info->gc_sections)
7904         return TRUE;
7905
7906       while ((p = *pp) != NULL)
7907         {
7908           if (p->sec == sec)
7909             {
7910               if (!must_be_dyn_reloc (info, r_type))
7911                 p->pc_count -= 1;
7912               p->count -= 1;
7913               if (p->count == 0)
7914                 *pp = p->next;
7915               return TRUE;
7916             }
7917           pp = &p->next;
7918         }
7919     }
7920   else
7921     {
7922       struct ppc_dyn_relocs *p;
7923       struct ppc_dyn_relocs **pp;
7924       void *vpp;
7925       bfd_boolean is_ifunc;
7926
7927       if (local_syms == NULL)
7928         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7929       if (sym_sec == NULL)
7930         sym_sec = sec;
7931
7932       vpp = &elf_section_data (sym_sec)->local_dynrel;
7933       pp = (struct ppc_dyn_relocs **) vpp;
7934
7935       if (*pp == NULL && info->gc_sections)
7936         return TRUE;
7937
7938       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7939       while ((p = *pp) != NULL)
7940         {
7941           if (p->sec == sec && p->ifunc == is_ifunc)
7942             {
7943               p->count -= 1;
7944               if (p->count == 0)
7945                 *pp = p->next;
7946               return TRUE;
7947             }
7948           pp = &p->next;
7949         }
7950     }
7951
7952   /* xgettext:c-format */
7953   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7954                           sec->owner, sec);
7955   bfd_set_error (bfd_error_bad_value);
7956   return FALSE;
7957 }
7958
7959 /* Remove unused Official Procedure Descriptor entries.  Currently we
7960    only remove those associated with functions in discarded link-once
7961    sections, or weakly defined functions that have been overridden.  It
7962    would be possible to remove many more entries for statically linked
7963    applications.  */
7964
7965 bfd_boolean
7966 ppc64_elf_edit_opd (struct bfd_link_info *info)
7967 {
7968   bfd *ibfd;
7969   bfd_boolean some_edited = FALSE;
7970   asection *need_pad = NULL;
7971   struct ppc_link_hash_table *htab;
7972
7973   htab = ppc_hash_table (info);
7974   if (htab == NULL)
7975     return FALSE;
7976
7977   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7978     {
7979       asection *sec;
7980       Elf_Internal_Rela *relstart, *rel, *relend;
7981       Elf_Internal_Shdr *symtab_hdr;
7982       Elf_Internal_Sym *local_syms;
7983       struct _opd_sec_data *opd;
7984       bfd_boolean need_edit, add_aux_fields, broken;
7985       bfd_size_type cnt_16b = 0;
7986
7987       if (!is_ppc64_elf (ibfd))
7988         continue;
7989
7990       sec = bfd_get_section_by_name (ibfd, ".opd");
7991       if (sec == NULL || sec->size == 0)
7992         continue;
7993
7994       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7995         continue;
7996
7997       if (sec->output_section == bfd_abs_section_ptr)
7998         continue;
7999
8000       /* Look through the section relocs.  */
8001       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
8002         continue;
8003
8004       local_syms = NULL;
8005       symtab_hdr = &elf_symtab_hdr (ibfd);
8006
8007       /* Read the relocations.  */
8008       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8009                                             info->keep_memory);
8010       if (relstart == NULL)
8011         return FALSE;
8012
8013       /* First run through the relocs to check they are sane, and to
8014          determine whether we need to edit this opd section.  */
8015       need_edit = FALSE;
8016       broken = FALSE;
8017       need_pad = sec;
8018       relend = relstart + sec->reloc_count;
8019       for (rel = relstart; rel < relend; )
8020         {
8021           enum elf_ppc64_reloc_type r_type;
8022           unsigned long r_symndx;
8023           asection *sym_sec;
8024           struct elf_link_hash_entry *h;
8025           Elf_Internal_Sym *sym;
8026           bfd_vma offset;
8027
8028           /* .opd contains an array of 16 or 24 byte entries.  We're
8029              only interested in the reloc pointing to a function entry
8030              point.  */
8031           offset = rel->r_offset;
8032           if (rel + 1 == relend
8033               || rel[1].r_offset != offset + 8)
8034             {
8035               /* If someone messes with .opd alignment then after a
8036                  "ld -r" we might have padding in the middle of .opd.
8037                  Also, there's nothing to prevent someone putting
8038                  something silly in .opd with the assembler.  No .opd
8039                  optimization for them!  */
8040             broken_opd:
8041               _bfd_error_handler
8042                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
8043               broken = TRUE;
8044               break;
8045             }
8046
8047           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8048               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8049             {
8050               _bfd_error_handler
8051                 /* xgettext:c-format */
8052                 (_("%B: unexpected reloc type %u in .opd section"),
8053                  ibfd, r_type);
8054               broken = TRUE;
8055               break;
8056             }
8057
8058           r_symndx = ELF64_R_SYM (rel->r_info);
8059           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8060                           r_symndx, ibfd))
8061             goto error_ret;
8062
8063           if (sym_sec == NULL || sym_sec->owner == NULL)
8064             {
8065               const char *sym_name;
8066               if (h != NULL)
8067                 sym_name = h->root.root.string;
8068               else
8069                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8070                                              sym_sec);
8071
8072               _bfd_error_handler
8073                 /* xgettext:c-format */
8074                 (_("%B: undefined sym `%s' in .opd section"),
8075                  ibfd, sym_name);
8076               broken = TRUE;
8077               break;
8078             }
8079
8080           /* opd entries are always for functions defined in the
8081              current input bfd.  If the symbol isn't defined in the
8082              input bfd, then we won't be using the function in this
8083              bfd;  It must be defined in a linkonce section in another
8084              bfd, or is weak.  It's also possible that we are
8085              discarding the function due to a linker script /DISCARD/,
8086              which we test for via the output_section.  */
8087           if (sym_sec->owner != ibfd
8088               || sym_sec->output_section == bfd_abs_section_ptr)
8089             need_edit = TRUE;
8090
8091           rel += 2;
8092           if (rel + 1 == relend
8093               || (rel + 2 < relend
8094                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8095             ++rel;
8096
8097           if (rel == relend)
8098             {
8099               if (sec->size == offset + 24)
8100                 {
8101                   need_pad = NULL;
8102                   break;
8103                 }
8104               if (sec->size == offset + 16)
8105                 {
8106                   cnt_16b++;
8107                   break;
8108                 }
8109               goto broken_opd;
8110             }
8111           else if (rel + 1 < relend
8112                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8113                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8114             {
8115               if (rel[0].r_offset == offset + 16)
8116                 cnt_16b++;
8117               else if (rel[0].r_offset != offset + 24)
8118                 goto broken_opd;
8119             }
8120           else
8121             goto broken_opd;
8122         }
8123
8124       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8125
8126       if (!broken && (need_edit || add_aux_fields))
8127         {
8128           Elf_Internal_Rela *write_rel;
8129           Elf_Internal_Shdr *rel_hdr;
8130           bfd_byte *rptr, *wptr;
8131           bfd_byte *new_contents;
8132           bfd_size_type amt;
8133
8134           new_contents = NULL;
8135           amt = OPD_NDX (sec->size) * sizeof (long);
8136           opd = &ppc64_elf_section_data (sec)->u.opd;
8137           opd->adjust = bfd_zalloc (sec->owner, amt);
8138           if (opd->adjust == NULL)
8139             return FALSE;
8140
8141           /* This seems a waste of time as input .opd sections are all
8142              zeros as generated by gcc, but I suppose there's no reason
8143              this will always be so.  We might start putting something in
8144              the third word of .opd entries.  */
8145           if ((sec->flags & SEC_IN_MEMORY) == 0)
8146             {
8147               bfd_byte *loc;
8148               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8149                 {
8150                   if (loc != NULL)
8151                     free (loc);
8152                 error_ret:
8153                   if (local_syms != NULL
8154                       && symtab_hdr->contents != (unsigned char *) local_syms)
8155                     free (local_syms);
8156                   if (elf_section_data (sec)->relocs != relstart)
8157                     free (relstart);
8158                   return FALSE;
8159                 }
8160               sec->contents = loc;
8161               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8162             }
8163
8164           elf_section_data (sec)->relocs = relstart;
8165
8166           new_contents = sec->contents;
8167           if (add_aux_fields)
8168             {
8169               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8170               if (new_contents == NULL)
8171                 return FALSE;
8172               need_pad = NULL;
8173             }
8174           wptr = new_contents;
8175           rptr = sec->contents;
8176           write_rel = relstart;
8177           for (rel = relstart; rel < relend; )
8178             {
8179               unsigned long r_symndx;
8180               asection *sym_sec;
8181               struct elf_link_hash_entry *h;
8182               struct ppc_link_hash_entry *fdh = NULL;
8183               Elf_Internal_Sym *sym;
8184               long opd_ent_size;
8185               Elf_Internal_Rela *next_rel;
8186               bfd_boolean skip;
8187
8188               r_symndx = ELF64_R_SYM (rel->r_info);
8189               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8190                               r_symndx, ibfd))
8191                 goto error_ret;
8192
8193               next_rel = rel + 2;
8194               if (next_rel + 1 == relend
8195                   || (next_rel + 2 < relend
8196                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8197                 ++next_rel;
8198
8199               /* See if the .opd entry is full 24 byte or
8200                  16 byte (with fd_aux entry overlapped with next
8201                  fd_func).  */
8202               opd_ent_size = 24;
8203               if (next_rel == relend)
8204                 {
8205                   if (sec->size == rel->r_offset + 16)
8206                     opd_ent_size = 16;
8207                 }
8208               else if (next_rel->r_offset == rel->r_offset + 16)
8209                 opd_ent_size = 16;
8210
8211               if (h != NULL
8212                   && h->root.root.string[0] == '.')
8213                 {
8214                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8215                   if (fdh != NULL)
8216                     {
8217                       fdh = ppc_follow_link (fdh);
8218                       if (fdh->elf.root.type != bfd_link_hash_defined
8219                           && fdh->elf.root.type != bfd_link_hash_defweak)
8220                         fdh = NULL;
8221                     }
8222                 }
8223
8224               skip = (sym_sec->owner != ibfd
8225                       || sym_sec->output_section == bfd_abs_section_ptr);
8226               if (skip)
8227                 {
8228                   if (fdh != NULL && sym_sec->owner == ibfd)
8229                     {
8230                       /* Arrange for the function descriptor sym
8231                          to be dropped.  */
8232                       fdh->elf.root.u.def.value = 0;
8233                       fdh->elf.root.u.def.section = sym_sec;
8234                     }
8235                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8236
8237                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8238                     rel = next_rel;
8239                   else
8240                     while (1)
8241                       {
8242                         if (!dec_dynrel_count (rel->r_info, sec, info,
8243                                                NULL, h, sym))
8244                           goto error_ret;
8245
8246                         if (++rel == next_rel)
8247                           break;
8248
8249                         r_symndx = ELF64_R_SYM (rel->r_info);
8250                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8251                                         r_symndx, ibfd))
8252                           goto error_ret;
8253                       }
8254                 }
8255               else
8256                 {
8257                   /* We'll be keeping this opd entry.  */
8258                   long adjust;
8259
8260                   if (fdh != NULL)
8261                     {
8262                       /* Redefine the function descriptor symbol to
8263                          this location in the opd section.  It is
8264                          necessary to update the value here rather
8265                          than using an array of adjustments as we do
8266                          for local symbols, because various places
8267                          in the generic ELF code use the value
8268                          stored in u.def.value.  */
8269                       fdh->elf.root.u.def.value = wptr - new_contents;
8270                       fdh->adjust_done = 1;
8271                     }
8272
8273                   /* Local syms are a bit tricky.  We could
8274                      tweak them as they can be cached, but
8275                      we'd need to look through the local syms
8276                      for the function descriptor sym which we
8277                      don't have at the moment.  So keep an
8278                      array of adjustments.  */
8279                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8280                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8281
8282                   if (wptr != rptr)
8283                     memcpy (wptr, rptr, opd_ent_size);
8284                   wptr += opd_ent_size;
8285                   if (add_aux_fields && opd_ent_size == 16)
8286                     {
8287                       memset (wptr, '\0', 8);
8288                       wptr += 8;
8289                     }
8290
8291                   /* We need to adjust any reloc offsets to point to the
8292                      new opd entries.  */
8293                   for ( ; rel != next_rel; ++rel)
8294                     {
8295                       rel->r_offset += adjust;
8296                       if (write_rel != rel)
8297                         memcpy (write_rel, rel, sizeof (*rel));
8298                       ++write_rel;
8299                     }
8300                 }
8301
8302               rptr += opd_ent_size;
8303             }
8304
8305           sec->size = wptr - new_contents;
8306           sec->reloc_count = write_rel - relstart;
8307           if (add_aux_fields)
8308             {
8309               free (sec->contents);
8310               sec->contents = new_contents;
8311             }
8312
8313           /* Fudge the header size too, as this is used later in
8314              elf_bfd_final_link if we are emitting relocs.  */
8315           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8316           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8317           some_edited = TRUE;
8318         }
8319       else if (elf_section_data (sec)->relocs != relstart)
8320         free (relstart);
8321
8322       if (local_syms != NULL
8323           && symtab_hdr->contents != (unsigned char *) local_syms)
8324         {
8325           if (!info->keep_memory)
8326             free (local_syms);
8327           else
8328             symtab_hdr->contents = (unsigned char *) local_syms;
8329         }
8330     }
8331
8332   if (some_edited)
8333     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8334
8335   /* If we are doing a final link and the last .opd entry is just 16 byte
8336      long, add a 8 byte padding after it.  */
8337   if (need_pad != NULL && !bfd_link_relocatable (info))
8338     {
8339       bfd_byte *p;
8340
8341       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8342         {
8343           BFD_ASSERT (need_pad->size > 0);
8344
8345           p = bfd_malloc (need_pad->size + 8);
8346           if (p == NULL)
8347             return FALSE;
8348
8349           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8350                                           p, 0, need_pad->size))
8351             return FALSE;
8352
8353           need_pad->contents = p;
8354           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8355         }
8356       else
8357         {
8358           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8359           if (p == NULL)
8360             return FALSE;
8361
8362           need_pad->contents = p;
8363         }
8364
8365       memset (need_pad->contents + need_pad->size, 0, 8);
8366       need_pad->size += 8;
8367     }
8368
8369   return TRUE;
8370 }
8371
8372 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8373
8374 asection *
8375 ppc64_elf_tls_setup (struct bfd_link_info *info)
8376 {
8377   struct ppc_link_hash_table *htab;
8378
8379   htab = ppc_hash_table (info);
8380   if (htab == NULL)
8381     return NULL;
8382
8383   if (abiversion (info->output_bfd) == 1)
8384     htab->opd_abi = 1;
8385
8386   if (htab->params->no_multi_toc)
8387     htab->do_multi_toc = 0;
8388   else if (!htab->do_multi_toc)
8389     htab->params->no_multi_toc = 1;
8390
8391   /* Default to --no-plt-localentry, as this option can cause problems
8392      with symbol interposition.  For example, glibc libpthread.so and
8393      libc.so duplicate many pthread symbols, with a fallback
8394      implementation in libc.so.  In some cases the fallback does more
8395      work than the pthread implementation.  __pthread_condattr_destroy
8396      is one such symbol: the libpthread.so implementation is
8397      localentry:0 while the libc.so implementation is localentry:8.
8398      An app that "cleverly" uses dlopen to only load necessary
8399      libraries at runtime may omit loading libpthread.so when not
8400      running multi-threaded, which then results in the libc.so
8401      fallback symbols being used and ld.so complaining.  Now there
8402      are workarounds in ld (see non_zero_localentry) to detect the
8403      pthread situation, but that may not be the only case where
8404      --plt-localentry can cause trouble.  */
8405   if (htab->params->plt_localentry0 < 0)
8406     htab->params->plt_localentry0 = 0;
8407   if (htab->params->plt_localentry0
8408       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8409                                FALSE, FALSE, FALSE) == NULL)
8410     info->callbacks->einfo
8411       (_("%P: warning: --plt-localentry is especially dangerous without "
8412          "ld.so support to detect ABI violations.\n"));
8413
8414   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8415                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8416                                               FALSE, FALSE, TRUE));
8417   /* Move dynamic linking info to the function descriptor sym.  */
8418   if (htab->tls_get_addr != NULL)
8419     func_desc_adjust (&htab->tls_get_addr->elf, info);
8420   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8421                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8422                                                  FALSE, FALSE, TRUE));
8423   if (htab->params->tls_get_addr_opt)
8424     {
8425       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8426
8427       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8428                                   FALSE, FALSE, TRUE);
8429       if (opt != NULL)
8430         func_desc_adjust (opt, info);
8431       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8432                                      FALSE, FALSE, TRUE);
8433       if (opt_fd != NULL
8434           && (opt_fd->root.type == bfd_link_hash_defined
8435               || opt_fd->root.type == bfd_link_hash_defweak))
8436         {
8437           /* If glibc supports an optimized __tls_get_addr call stub,
8438              signalled by the presence of __tls_get_addr_opt, and we'll
8439              be calling __tls_get_addr via a plt call stub, then
8440              make __tls_get_addr point to __tls_get_addr_opt.  */
8441           tga_fd = &htab->tls_get_addr_fd->elf;
8442           if (htab->elf.dynamic_sections_created
8443               && tga_fd != NULL
8444               && (tga_fd->type == STT_FUNC
8445                   || tga_fd->needs_plt)
8446               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8447                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8448             {
8449               struct plt_entry *ent;
8450
8451               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8452                 if (ent->plt.refcount > 0)
8453                   break;
8454               if (ent != NULL)
8455                 {
8456                   tga_fd->root.type = bfd_link_hash_indirect;
8457                   tga_fd->root.u.i.link = &opt_fd->root;
8458                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8459                   opt_fd->mark = 1;
8460                   if (opt_fd->dynindx != -1)
8461                     {
8462                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8463                       opt_fd->dynindx = -1;
8464                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8465                                               opt_fd->dynstr_index);
8466                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8467                         return NULL;
8468                     }
8469                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8470                   tga = &htab->tls_get_addr->elf;
8471                   if (opt != NULL && tga != NULL)
8472                     {
8473                       tga->root.type = bfd_link_hash_indirect;
8474                       tga->root.u.i.link = &opt->root;
8475                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8476                       opt->mark = 1;
8477                       _bfd_elf_link_hash_hide_symbol (info, opt,
8478                                                       tga->forced_local);
8479                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8480                     }
8481                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8482                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8483                   if (htab->tls_get_addr != NULL)
8484                     {
8485                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8486                       htab->tls_get_addr->is_func = 1;
8487                     }
8488                 }
8489             }
8490         }
8491       else if (htab->params->tls_get_addr_opt < 0)
8492         htab->params->tls_get_addr_opt = 0;
8493     }
8494   return _bfd_elf_tls_setup (info->output_bfd, info);
8495 }
8496
8497 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8498    HASH1 or HASH2.  */
8499
8500 static bfd_boolean
8501 branch_reloc_hash_match (const bfd *ibfd,
8502                          const Elf_Internal_Rela *rel,
8503                          const struct ppc_link_hash_entry *hash1,
8504                          const struct ppc_link_hash_entry *hash2)
8505 {
8506   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8507   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8508   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8509
8510   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8511     {
8512       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8513       struct elf_link_hash_entry *h;
8514
8515       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8516       h = elf_follow_link (h);
8517       if (h == &hash1->elf || h == &hash2->elf)
8518         return TRUE;
8519     }
8520   return FALSE;
8521 }
8522
8523 /* Run through all the TLS relocs looking for optimization
8524    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8525    a preliminary section layout so that we know the TLS segment
8526    offsets.  We can't optimize earlier because some optimizations need
8527    to know the tp offset, and we need to optimize before allocating
8528    dynamic relocations.  */
8529
8530 bfd_boolean
8531 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8532 {
8533   bfd *ibfd;
8534   asection *sec;
8535   struct ppc_link_hash_table *htab;
8536   unsigned char *toc_ref;
8537   int pass;
8538
8539   if (!bfd_link_executable (info))
8540     return TRUE;
8541
8542   htab = ppc_hash_table (info);
8543   if (htab == NULL)
8544     return FALSE;
8545
8546   /* Make two passes over the relocs.  On the first pass, mark toc
8547      entries involved with tls relocs, and check that tls relocs
8548      involved in setting up a tls_get_addr call are indeed followed by
8549      such a call.  If they are not, we can't do any tls optimization.
8550      On the second pass twiddle tls_mask flags to notify
8551      relocate_section that optimization can be done, and adjust got
8552      and plt refcounts.  */
8553   toc_ref = NULL;
8554   for (pass = 0; pass < 2; ++pass)
8555     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8556       {
8557         Elf_Internal_Sym *locsyms = NULL;
8558         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8559
8560         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8561           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8562             {
8563               Elf_Internal_Rela *relstart, *rel, *relend;
8564               bfd_boolean found_tls_get_addr_arg = 0;
8565
8566               /* Read the relocations.  */
8567               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8568                                                     info->keep_memory);
8569               if (relstart == NULL)
8570                 {
8571                   free (toc_ref);
8572                   return FALSE;
8573                 }
8574
8575               relend = relstart + sec->reloc_count;
8576               for (rel = relstart; rel < relend; rel++)
8577                 {
8578                   enum elf_ppc64_reloc_type r_type;
8579                   unsigned long r_symndx;
8580                   struct elf_link_hash_entry *h;
8581                   Elf_Internal_Sym *sym;
8582                   asection *sym_sec;
8583                   unsigned char *tls_mask;
8584                   unsigned char tls_set, tls_clear, tls_type = 0;
8585                   bfd_vma value;
8586                   bfd_boolean ok_tprel, is_local;
8587                   long toc_ref_index = 0;
8588                   int expecting_tls_get_addr = 0;
8589                   bfd_boolean ret = FALSE;
8590
8591                   r_symndx = ELF64_R_SYM (rel->r_info);
8592                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8593                                   r_symndx, ibfd))
8594                     {
8595                     err_free_rel:
8596                       if (elf_section_data (sec)->relocs != relstart)
8597                         free (relstart);
8598                       if (toc_ref != NULL)
8599                         free (toc_ref);
8600                       if (locsyms != NULL
8601                           && (elf_symtab_hdr (ibfd).contents
8602                               != (unsigned char *) locsyms))
8603                         free (locsyms);
8604                       return ret;
8605                     }
8606
8607                   if (h != NULL)
8608                     {
8609                       if (h->root.type == bfd_link_hash_defined
8610                           || h->root.type == bfd_link_hash_defweak)
8611                         value = h->root.u.def.value;
8612                       else if (h->root.type == bfd_link_hash_undefweak)
8613                         value = 0;
8614                       else
8615                         {
8616                           found_tls_get_addr_arg = 0;
8617                           continue;
8618                         }
8619                     }
8620                   else
8621                     /* Symbols referenced by TLS relocs must be of type
8622                        STT_TLS.  So no need for .opd local sym adjust.  */
8623                     value = sym->st_value;
8624
8625                   ok_tprel = FALSE;
8626                   is_local = FALSE;
8627                   if (h == NULL
8628                       || !h->def_dynamic)
8629                     {
8630                       is_local = TRUE;
8631                       if (h != NULL
8632                           && h->root.type == bfd_link_hash_undefweak)
8633                         ok_tprel = TRUE;
8634                       else if (sym_sec != NULL
8635                                && sym_sec->output_section != NULL)
8636                         {
8637                           value += sym_sec->output_offset;
8638                           value += sym_sec->output_section->vma;
8639                           value -= htab->elf.tls_sec->vma;
8640                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8641                                       < (bfd_vma) 1 << 32);
8642                         }
8643                     }
8644
8645                   r_type = ELF64_R_TYPE (rel->r_info);
8646                   /* If this section has old-style __tls_get_addr calls
8647                      without marker relocs, then check that each
8648                      __tls_get_addr call reloc is preceded by a reloc
8649                      that conceivably belongs to the __tls_get_addr arg
8650                      setup insn.  If we don't find matching arg setup
8651                      relocs, don't do any tls optimization.  */
8652                   if (pass == 0
8653                       && sec->has_tls_get_addr_call
8654                       && h != NULL
8655                       && (h == &htab->tls_get_addr->elf
8656                           || h == &htab->tls_get_addr_fd->elf)
8657                       && !found_tls_get_addr_arg
8658                       && is_branch_reloc (r_type))
8659                     {
8660                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8661                                                 "TLS optimization disabled\n"),
8662                                               ibfd, sec, rel->r_offset);
8663                       ret = TRUE;
8664                       goto err_free_rel;
8665                     }
8666
8667                   found_tls_get_addr_arg = 0;
8668                   switch (r_type)
8669                     {
8670                     case R_PPC64_GOT_TLSLD16:
8671                     case R_PPC64_GOT_TLSLD16_LO:
8672                       expecting_tls_get_addr = 1;
8673                       found_tls_get_addr_arg = 1;
8674                       /* Fall through.  */
8675
8676                     case R_PPC64_GOT_TLSLD16_HI:
8677                     case R_PPC64_GOT_TLSLD16_HA:
8678                       /* These relocs should never be against a symbol
8679                          defined in a shared lib.  Leave them alone if
8680                          that turns out to be the case.  */
8681                       if (!is_local)
8682                         continue;
8683
8684                       /* LD -> LE */
8685                       tls_set = 0;
8686                       tls_clear = TLS_LD;
8687                       tls_type = TLS_TLS | TLS_LD;
8688                       break;
8689
8690                     case R_PPC64_GOT_TLSGD16:
8691                     case R_PPC64_GOT_TLSGD16_LO:
8692                       expecting_tls_get_addr = 1;
8693                       found_tls_get_addr_arg = 1;
8694                       /* Fall through. */
8695
8696                     case R_PPC64_GOT_TLSGD16_HI:
8697                     case R_PPC64_GOT_TLSGD16_HA:
8698                       if (ok_tprel)
8699                         /* GD -> LE */
8700                         tls_set = 0;
8701                       else
8702                         /* GD -> IE */
8703                         tls_set = TLS_TLS | TLS_TPRELGD;
8704                       tls_clear = TLS_GD;
8705                       tls_type = TLS_TLS | TLS_GD;
8706                       break;
8707
8708                     case R_PPC64_GOT_TPREL16_DS:
8709                     case R_PPC64_GOT_TPREL16_LO_DS:
8710                     case R_PPC64_GOT_TPREL16_HI:
8711                     case R_PPC64_GOT_TPREL16_HA:
8712                       if (ok_tprel)
8713                         {
8714                           /* IE -> LE */
8715                           tls_set = 0;
8716                           tls_clear = TLS_TPREL;
8717                           tls_type = TLS_TLS | TLS_TPREL;
8718                           break;
8719                         }
8720                       continue;
8721
8722                     case R_PPC64_TLSGD:
8723                     case R_PPC64_TLSLD:
8724                       found_tls_get_addr_arg = 1;
8725                       /* Fall through.  */
8726
8727                     case R_PPC64_TLS:
8728                     case R_PPC64_TOC16:
8729                     case R_PPC64_TOC16_LO:
8730                       if (sym_sec == NULL || sym_sec != toc)
8731                         continue;
8732
8733                       /* Mark this toc entry as referenced by a TLS
8734                          code sequence.  We can do that now in the
8735                          case of R_PPC64_TLS, and after checking for
8736                          tls_get_addr for the TOC16 relocs.  */
8737                       if (toc_ref == NULL)
8738                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8739                       if (toc_ref == NULL)
8740                         goto err_free_rel;
8741
8742                       if (h != NULL)
8743                         value = h->root.u.def.value;
8744                       else
8745                         value = sym->st_value;
8746                       value += rel->r_addend;
8747                       if (value % 8 != 0)
8748                         continue;
8749                       BFD_ASSERT (value < toc->size
8750                                   && toc->output_offset % 8 == 0);
8751                       toc_ref_index = (value + toc->output_offset) / 8;
8752                       if (r_type == R_PPC64_TLS
8753                           || r_type == R_PPC64_TLSGD
8754                           || r_type == R_PPC64_TLSLD)
8755                         {
8756                           toc_ref[toc_ref_index] = 1;
8757                           continue;
8758                         }
8759
8760                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8761                         continue;
8762
8763                       tls_set = 0;
8764                       tls_clear = 0;
8765                       expecting_tls_get_addr = 2;
8766                       break;
8767
8768                     case R_PPC64_TPREL64:
8769                       if (pass == 0
8770                           || sec != toc
8771                           || toc_ref == NULL
8772                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8773                         continue;
8774                       if (ok_tprel)
8775                         {
8776                           /* IE -> LE */
8777                           tls_set = TLS_EXPLICIT;
8778                           tls_clear = TLS_TPREL;
8779                           break;
8780                         }
8781                       continue;
8782
8783                     case R_PPC64_DTPMOD64:
8784                       if (pass == 0
8785                           || sec != toc
8786                           || toc_ref == NULL
8787                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8788                         continue;
8789                       if (rel + 1 < relend
8790                           && (rel[1].r_info
8791                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8792                           && rel[1].r_offset == rel->r_offset + 8)
8793                         {
8794                           if (ok_tprel)
8795                             /* GD -> LE */
8796                             tls_set = TLS_EXPLICIT | TLS_GD;
8797                           else
8798                             /* GD -> IE */
8799                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8800                           tls_clear = TLS_GD;
8801                         }
8802                       else
8803                         {
8804                           if (!is_local)
8805                             continue;
8806
8807                           /* LD -> LE */
8808                           tls_set = TLS_EXPLICIT;
8809                           tls_clear = TLS_LD;
8810                         }
8811                       break;
8812
8813                     default:
8814                       continue;
8815                     }
8816
8817                   if (pass == 0)
8818                     {
8819                       if (!expecting_tls_get_addr
8820                           || !sec->has_tls_get_addr_call)
8821                         continue;
8822
8823                       if (rel + 1 < relend
8824                           && branch_reloc_hash_match (ibfd, rel + 1,
8825                                                       htab->tls_get_addr,
8826                                                       htab->tls_get_addr_fd))
8827                         {
8828                           if (expecting_tls_get_addr == 2)
8829                             {
8830                               /* Check for toc tls entries.  */
8831                               unsigned char *toc_tls;
8832                               int retval;
8833
8834                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8835                                                      &locsyms,
8836                                                      rel, ibfd);
8837                               if (retval == 0)
8838                                 goto err_free_rel;
8839                               if (toc_tls != NULL)
8840                                 {
8841                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8842                                     found_tls_get_addr_arg = 1;
8843                                   if (retval > 1)
8844                                     toc_ref[toc_ref_index] = 1;
8845                                 }
8846                             }
8847                           continue;
8848                         }
8849
8850                       if (expecting_tls_get_addr != 1)
8851                         continue;
8852
8853                       /* Uh oh, we didn't find the expected call.  We
8854                          could just mark this symbol to exclude it
8855                          from tls optimization but it's safer to skip
8856                          the entire optimization.  */
8857                       /* xgettext:c-format */
8858                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8859                                                 "TLS optimization disabled\n"),
8860                                               ibfd, sec, rel->r_offset);
8861                       ret = TRUE;
8862                       goto err_free_rel;
8863                     }
8864
8865                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8866                     {
8867                       struct plt_entry *ent;
8868                       for (ent = htab->tls_get_addr->elf.plt.plist;
8869                            ent != NULL;
8870                            ent = ent->next)
8871                         if (ent->addend == 0)
8872                           {
8873                             if (ent->plt.refcount > 0)
8874                               {
8875                                 ent->plt.refcount -= 1;
8876                                 expecting_tls_get_addr = 0;
8877                               }
8878                             break;
8879                           }
8880                     }
8881
8882                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8883                     {
8884                       struct plt_entry *ent;
8885                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8886                            ent != NULL;
8887                            ent = ent->next)
8888                         if (ent->addend == 0)
8889                           {
8890                             if (ent->plt.refcount > 0)
8891                               ent->plt.refcount -= 1;
8892                             break;
8893                           }
8894                     }
8895
8896                   if (tls_clear == 0)
8897                     continue;
8898
8899                   if ((tls_set & TLS_EXPLICIT) == 0)
8900                     {
8901                       struct got_entry *ent;
8902
8903                       /* Adjust got entry for this reloc.  */
8904                       if (h != NULL)
8905                         ent = h->got.glist;
8906                       else
8907                         ent = elf_local_got_ents (ibfd)[r_symndx];
8908
8909                       for (; ent != NULL; ent = ent->next)
8910                         if (ent->addend == rel->r_addend
8911                             && ent->owner == ibfd
8912                             && ent->tls_type == tls_type)
8913                           break;
8914                       if (ent == NULL)
8915                         abort ();
8916
8917                       if (tls_set == 0)
8918                         {
8919                           /* We managed to get rid of a got entry.  */
8920                           if (ent->got.refcount > 0)
8921                             ent->got.refcount -= 1;
8922                         }
8923                     }
8924                   else
8925                     {
8926                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8927                          we'll lose one or two dyn relocs.  */
8928                       if (!dec_dynrel_count (rel->r_info, sec, info,
8929                                              NULL, h, sym))
8930                         return FALSE;
8931
8932                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8933                         {
8934                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8935                                                  NULL, h, sym))
8936                             return FALSE;
8937                         }
8938                     }
8939
8940                   *tls_mask |= tls_set;
8941                   *tls_mask &= ~tls_clear;
8942                 }
8943
8944               if (elf_section_data (sec)->relocs != relstart)
8945                 free (relstart);
8946             }
8947
8948         if (locsyms != NULL
8949             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8950           {
8951             if (!info->keep_memory)
8952               free (locsyms);
8953             else
8954               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8955           }
8956       }
8957
8958   if (toc_ref != NULL)
8959     free (toc_ref);
8960   htab->do_tls_opt = 1;
8961   return TRUE;
8962 }
8963
8964 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8965    the values of any global symbols in a toc section that has been
8966    edited.  Globals in toc sections should be a rarity, so this function
8967    sets a flag if any are found in toc sections other than the one just
8968    edited, so that further hash table traversals can be avoided.  */
8969
8970 struct adjust_toc_info
8971 {
8972   asection *toc;
8973   unsigned long *skip;
8974   bfd_boolean global_toc_syms;
8975 };
8976
8977 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8978
8979 static bfd_boolean
8980 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8981 {
8982   struct ppc_link_hash_entry *eh;
8983   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8984   unsigned long i;
8985
8986   if (h->root.type != bfd_link_hash_defined
8987       && h->root.type != bfd_link_hash_defweak)
8988     return TRUE;
8989
8990   eh = (struct ppc_link_hash_entry *) h;
8991   if (eh->adjust_done)
8992     return TRUE;
8993
8994   if (eh->elf.root.u.def.section == toc_inf->toc)
8995     {
8996       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8997         i = toc_inf->toc->rawsize >> 3;
8998       else
8999         i = eh->elf.root.u.def.value >> 3;
9000
9001       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9002         {
9003           _bfd_error_handler
9004             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9005           do
9006             ++i;
9007           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9008           eh->elf.root.u.def.value = (bfd_vma) i << 3;
9009         }
9010
9011       eh->elf.root.u.def.value -= toc_inf->skip[i];
9012       eh->adjust_done = 1;
9013     }
9014   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9015     toc_inf->global_toc_syms = TRUE;
9016
9017   return TRUE;
9018 }
9019
9020 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9021    on a _LO variety toc/got reloc.  */
9022
9023 static bfd_boolean
9024 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9025 {
9026   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9027           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9028           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9029           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9030           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9031           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9032           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9033           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9034           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9035           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9036           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9037           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9038           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9039           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9040           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9041           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9042           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9043               /* Exclude lfqu by testing reloc.  If relocs are ever
9044                  defined for the reduced D field in psq_lu then those
9045                  will need testing too.  */
9046               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9047           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9048               && (insn & 1) == 0)
9049           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9050           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9051               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
9052               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9053           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9054               && (insn & 1) == 0));
9055 }
9056
9057 /* Examine all relocs referencing .toc sections in order to remove
9058    unused .toc entries.  */
9059
9060 bfd_boolean
9061 ppc64_elf_edit_toc (struct bfd_link_info *info)
9062 {
9063   bfd *ibfd;
9064   struct adjust_toc_info toc_inf;
9065   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9066
9067   htab->do_toc_opt = 1;
9068   toc_inf.global_toc_syms = TRUE;
9069   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9070     {
9071       asection *toc, *sec;
9072       Elf_Internal_Shdr *symtab_hdr;
9073       Elf_Internal_Sym *local_syms;
9074       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9075       unsigned long *skip, *drop;
9076       unsigned char *used;
9077       unsigned char *keep, last, some_unused;
9078
9079       if (!is_ppc64_elf (ibfd))
9080         continue;
9081
9082       toc = bfd_get_section_by_name (ibfd, ".toc");
9083       if (toc == NULL
9084           || toc->size == 0
9085           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9086           || discarded_section (toc))
9087         continue;
9088
9089       toc_relocs = NULL;
9090       local_syms = NULL;
9091       symtab_hdr = &elf_symtab_hdr (ibfd);
9092
9093       /* Look at sections dropped from the final link.  */
9094       skip = NULL;
9095       relstart = NULL;
9096       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9097         {
9098           if (sec->reloc_count == 0
9099               || !discarded_section (sec)
9100               || get_opd_info (sec)
9101               || (sec->flags & SEC_ALLOC) == 0
9102               || (sec->flags & SEC_DEBUGGING) != 0)
9103             continue;
9104
9105           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9106           if (relstart == NULL)
9107             goto error_ret;
9108
9109           /* Run through the relocs to see which toc entries might be
9110              unused.  */
9111           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9112             {
9113               enum elf_ppc64_reloc_type r_type;
9114               unsigned long r_symndx;
9115               asection *sym_sec;
9116               struct elf_link_hash_entry *h;
9117               Elf_Internal_Sym *sym;
9118               bfd_vma val;
9119
9120               r_type = ELF64_R_TYPE (rel->r_info);
9121               switch (r_type)
9122                 {
9123                 default:
9124                   continue;
9125
9126                 case R_PPC64_TOC16:
9127                 case R_PPC64_TOC16_LO:
9128                 case R_PPC64_TOC16_HI:
9129                 case R_PPC64_TOC16_HA:
9130                 case R_PPC64_TOC16_DS:
9131                 case R_PPC64_TOC16_LO_DS:
9132                   break;
9133                 }
9134
9135               r_symndx = ELF64_R_SYM (rel->r_info);
9136               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9137                               r_symndx, ibfd))
9138                 goto error_ret;
9139
9140               if (sym_sec != toc)
9141                 continue;
9142
9143               if (h != NULL)
9144                 val = h->root.u.def.value;
9145               else
9146                 val = sym->st_value;
9147               val += rel->r_addend;
9148
9149               if (val >= toc->size)
9150                 continue;
9151
9152               /* Anything in the toc ought to be aligned to 8 bytes.
9153                  If not, don't mark as unused.  */
9154               if (val & 7)
9155                 continue;
9156
9157               if (skip == NULL)
9158                 {
9159                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9160                   if (skip == NULL)
9161                     goto error_ret;
9162                 }
9163
9164               skip[val >> 3] = ref_from_discarded;
9165             }
9166
9167           if (elf_section_data (sec)->relocs != relstart)
9168             free (relstart);
9169         }
9170
9171       /* For largetoc loads of address constants, we can convert
9172          .  addis rx,2,addr@got@ha
9173          .  ld ry,addr@got@l(rx)
9174          to
9175          .  addis rx,2,addr@toc@ha
9176          .  addi ry,rx,addr@toc@l
9177          when addr is within 2G of the toc pointer.  This then means
9178          that the word storing "addr" in the toc is no longer needed.  */
9179
9180       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9181           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9182           && toc->reloc_count != 0)
9183         {
9184           /* Read toc relocs.  */
9185           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9186                                                   info->keep_memory);
9187           if (toc_relocs == NULL)
9188             goto error_ret;
9189
9190           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9191             {
9192               enum elf_ppc64_reloc_type r_type;
9193               unsigned long r_symndx;
9194               asection *sym_sec;
9195               struct elf_link_hash_entry *h;
9196               Elf_Internal_Sym *sym;
9197               bfd_vma val, addr;
9198
9199               r_type = ELF64_R_TYPE (rel->r_info);
9200               if (r_type != R_PPC64_ADDR64)
9201                 continue;
9202
9203               r_symndx = ELF64_R_SYM (rel->r_info);
9204               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9205                               r_symndx, ibfd))
9206                 goto error_ret;
9207
9208               if (sym_sec == NULL
9209                   || sym_sec->output_section == NULL
9210                   || discarded_section (sym_sec))
9211                 continue;
9212
9213               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9214                 continue;
9215
9216               if (h != NULL)
9217                 {
9218                   if (h->type == STT_GNU_IFUNC)
9219                     continue;
9220                   val = h->root.u.def.value;
9221                 }
9222               else
9223                 {
9224                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9225                     continue;
9226                   val = sym->st_value;
9227                 }
9228               val += rel->r_addend;
9229               val += sym_sec->output_section->vma + sym_sec->output_offset;
9230
9231               /* We don't yet know the exact toc pointer value, but we
9232                  know it will be somewhere in the toc section.  Don't
9233                  optimize if the difference from any possible toc
9234                  pointer is outside [ff..f80008000, 7fff7fff].  */
9235               addr = toc->output_section->vma + TOC_BASE_OFF;
9236               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9237                 continue;
9238
9239               addr = toc->output_section->vma + toc->output_section->rawsize;
9240               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9241                 continue;
9242
9243               if (skip == NULL)
9244                 {
9245                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9246                   if (skip == NULL)
9247                     goto error_ret;
9248                 }
9249
9250               skip[rel->r_offset >> 3]
9251                 |= can_optimize | ((rel - toc_relocs) << 2);
9252             }
9253         }
9254
9255       if (skip == NULL)
9256         continue;
9257
9258       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9259       if (used == NULL)
9260         {
9261         error_ret:
9262           if (local_syms != NULL
9263               && symtab_hdr->contents != (unsigned char *) local_syms)
9264             free (local_syms);
9265           if (sec != NULL
9266               && relstart != NULL
9267               && elf_section_data (sec)->relocs != relstart)
9268             free (relstart);
9269           if (toc_relocs != NULL
9270               && elf_section_data (toc)->relocs != toc_relocs)
9271             free (toc_relocs);
9272           if (skip != NULL)
9273             free (skip);
9274           return FALSE;
9275         }
9276
9277       /* Now check all kept sections that might reference the toc.
9278          Check the toc itself last.  */
9279       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9280                   : ibfd->sections);
9281            sec != NULL;
9282            sec = (sec == toc ? NULL
9283                   : sec->next == NULL ? toc
9284                   : sec->next == toc && toc->next ? toc->next
9285                   : sec->next))
9286         {
9287           int repeat;
9288
9289           if (sec->reloc_count == 0
9290               || discarded_section (sec)
9291               || get_opd_info (sec)
9292               || (sec->flags & SEC_ALLOC) == 0
9293               || (sec->flags & SEC_DEBUGGING) != 0)
9294             continue;
9295
9296           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9297                                                 info->keep_memory);
9298           if (relstart == NULL)
9299             {
9300               free (used);
9301               goto error_ret;
9302             }
9303
9304           /* Mark toc entries referenced as used.  */
9305           do
9306             {
9307               repeat = 0;
9308               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9309                 {
9310                   enum elf_ppc64_reloc_type r_type;
9311                   unsigned long r_symndx;
9312                   asection *sym_sec;
9313                   struct elf_link_hash_entry *h;
9314                   Elf_Internal_Sym *sym;
9315                   bfd_vma val;
9316                   enum {no_check, check_lo, check_ha} insn_check;
9317
9318                   r_type = ELF64_R_TYPE (rel->r_info);
9319                   switch (r_type)
9320                     {
9321                     default:
9322                       insn_check = no_check;
9323                       break;
9324
9325                     case R_PPC64_GOT_TLSLD16_HA:
9326                     case R_PPC64_GOT_TLSGD16_HA:
9327                     case R_PPC64_GOT_TPREL16_HA:
9328                     case R_PPC64_GOT_DTPREL16_HA:
9329                     case R_PPC64_GOT16_HA:
9330                     case R_PPC64_TOC16_HA:
9331                       insn_check = check_ha;
9332                       break;
9333
9334                     case R_PPC64_GOT_TLSLD16_LO:
9335                     case R_PPC64_GOT_TLSGD16_LO:
9336                     case R_PPC64_GOT_TPREL16_LO_DS:
9337                     case R_PPC64_GOT_DTPREL16_LO_DS:
9338                     case R_PPC64_GOT16_LO:
9339                     case R_PPC64_GOT16_LO_DS:
9340                     case R_PPC64_TOC16_LO:
9341                     case R_PPC64_TOC16_LO_DS:
9342                       insn_check = check_lo;
9343                       break;
9344                     }
9345
9346                   if (insn_check != no_check)
9347                     {
9348                       bfd_vma off = rel->r_offset & ~3;
9349                       unsigned char buf[4];
9350                       unsigned int insn;
9351
9352                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9353                         {
9354                           free (used);
9355                           goto error_ret;
9356                         }
9357                       insn = bfd_get_32 (ibfd, buf);
9358                       if (insn_check == check_lo
9359                           ? !ok_lo_toc_insn (insn, r_type)
9360                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9361                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9362                         {
9363                           char str[12];
9364
9365                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9366                           sprintf (str, "%#08x", insn);
9367                           info->callbacks->einfo
9368                             /* xgettext:c-format */
9369                             (_("%H: toc optimization is not supported for"
9370                                " %s instruction.\n"),
9371                              ibfd, sec, rel->r_offset & ~3, str);
9372                         }
9373                     }
9374
9375                   switch (r_type)
9376                     {
9377                     case R_PPC64_TOC16:
9378                     case R_PPC64_TOC16_LO:
9379                     case R_PPC64_TOC16_HI:
9380                     case R_PPC64_TOC16_HA:
9381                     case R_PPC64_TOC16_DS:
9382                     case R_PPC64_TOC16_LO_DS:
9383                       /* In case we're taking addresses of toc entries.  */
9384                     case R_PPC64_ADDR64:
9385                       break;
9386
9387                     default:
9388                       continue;
9389                     }
9390
9391                   r_symndx = ELF64_R_SYM (rel->r_info);
9392                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9393                                   r_symndx, ibfd))
9394                     {
9395                       free (used);
9396                       goto error_ret;
9397                     }
9398
9399                   if (sym_sec != toc)
9400                     continue;
9401
9402                   if (h != NULL)
9403                     val = h->root.u.def.value;
9404                   else
9405                     val = sym->st_value;
9406                   val += rel->r_addend;
9407
9408                   if (val >= toc->size)
9409                     continue;
9410
9411                   if ((skip[val >> 3] & can_optimize) != 0)
9412                     {
9413                       bfd_vma off;
9414                       unsigned char opc;
9415
9416                       switch (r_type)
9417                         {
9418                         case R_PPC64_TOC16_HA:
9419                           break;
9420
9421                         case R_PPC64_TOC16_LO_DS:
9422                           off = rel->r_offset;
9423                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9424                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9425                                                          off, 1))
9426                             {
9427                               free (used);
9428                               goto error_ret;
9429                             }
9430                           if ((opc & (0x3f << 2)) == (58u << 2))
9431                             break;
9432                           /* Fall through.  */
9433
9434                         default:
9435                           /* Wrong sort of reloc, or not a ld.  We may
9436                              as well clear ref_from_discarded too.  */
9437                           skip[val >> 3] = 0;
9438                         }
9439                     }
9440
9441                   if (sec != toc)
9442                     used[val >> 3] = 1;
9443                   /* For the toc section, we only mark as used if this
9444                      entry itself isn't unused.  */
9445                   else if ((used[rel->r_offset >> 3]
9446                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9447                            && !used[val >> 3])
9448                     {
9449                       /* Do all the relocs again, to catch reference
9450                          chains.  */
9451                       repeat = 1;
9452                       used[val >> 3] = 1;
9453                     }
9454                 }
9455             }
9456           while (repeat);
9457
9458           if (elf_section_data (sec)->relocs != relstart)
9459             free (relstart);
9460         }
9461
9462       /* Merge the used and skip arrays.  Assume that TOC
9463          doublewords not appearing as either used or unused belong
9464          to an entry more than one doubleword in size.  */
9465       for (drop = skip, keep = used, last = 0, some_unused = 0;
9466            drop < skip + (toc->size + 7) / 8;
9467            ++drop, ++keep)
9468         {
9469           if (*keep)
9470             {
9471               *drop &= ~ref_from_discarded;
9472               if ((*drop & can_optimize) != 0)
9473                 some_unused = 1;
9474               last = 0;
9475             }
9476           else if ((*drop & ref_from_discarded) != 0)
9477             {
9478               some_unused = 1;
9479               last = ref_from_discarded;
9480             }
9481           else
9482             *drop = last;
9483         }
9484
9485       free (used);
9486
9487       if (some_unused)
9488         {
9489           bfd_byte *contents, *src;
9490           unsigned long off;
9491           Elf_Internal_Sym *sym;
9492           bfd_boolean local_toc_syms = FALSE;
9493
9494           /* Shuffle the toc contents, and at the same time convert the
9495              skip array from booleans into offsets.  */
9496           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9497             goto error_ret;
9498
9499           elf_section_data (toc)->this_hdr.contents = contents;
9500
9501           for (src = contents, off = 0, drop = skip;
9502                src < contents + toc->size;
9503                src += 8, ++drop)
9504             {
9505               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9506                 off += 8;
9507               else if (off != 0)
9508                 {
9509                   *drop = off;
9510                   memcpy (src - off, src, 8);
9511                 }
9512             }
9513           *drop = off;
9514           toc->rawsize = toc->size;
9515           toc->size = src - contents - off;
9516
9517           /* Adjust addends for relocs against the toc section sym,
9518              and optimize any accesses we can.  */
9519           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9520             {
9521               if (sec->reloc_count == 0
9522                   || discarded_section (sec))
9523                 continue;
9524
9525               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9526                                                     info->keep_memory);
9527               if (relstart == NULL)
9528                 goto error_ret;
9529
9530               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9531                 {
9532                   enum elf_ppc64_reloc_type r_type;
9533                   unsigned long r_symndx;
9534                   asection *sym_sec;
9535                   struct elf_link_hash_entry *h;
9536                   bfd_vma val;
9537
9538                   r_type = ELF64_R_TYPE (rel->r_info);
9539                   switch (r_type)
9540                     {
9541                     default:
9542                       continue;
9543
9544                     case R_PPC64_TOC16:
9545                     case R_PPC64_TOC16_LO:
9546                     case R_PPC64_TOC16_HI:
9547                     case R_PPC64_TOC16_HA:
9548                     case R_PPC64_TOC16_DS:
9549                     case R_PPC64_TOC16_LO_DS:
9550                     case R_PPC64_ADDR64:
9551                       break;
9552                     }
9553
9554                   r_symndx = ELF64_R_SYM (rel->r_info);
9555                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9556                                   r_symndx, ibfd))
9557                     goto error_ret;
9558
9559                   if (sym_sec != toc)
9560                     continue;
9561
9562                   if (h != NULL)
9563                     val = h->root.u.def.value;
9564                   else
9565                     {
9566                       val = sym->st_value;
9567                       if (val != 0)
9568                         local_toc_syms = TRUE;
9569                     }
9570
9571                   val += rel->r_addend;
9572
9573                   if (val > toc->rawsize)
9574                     val = toc->rawsize;
9575                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9576                     continue;
9577                   else if ((skip[val >> 3] & can_optimize) != 0)
9578                     {
9579                       Elf_Internal_Rela *tocrel
9580                         = toc_relocs + (skip[val >> 3] >> 2);
9581                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9582
9583                       switch (r_type)
9584                         {
9585                         case R_PPC64_TOC16_HA:
9586                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9587                           break;
9588
9589                         case R_PPC64_TOC16_LO_DS:
9590                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9591                           break;
9592
9593                         default:
9594                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9595                             ppc_howto_init ();
9596                           info->callbacks->einfo
9597                             /* xgettext:c-format */
9598                             (_("%H: %s references "
9599                                "optimized away TOC entry\n"),
9600                              ibfd, sec, rel->r_offset,
9601                              ppc64_elf_howto_table[r_type]->name);
9602                           bfd_set_error (bfd_error_bad_value);
9603                           goto error_ret;
9604                         }
9605                       rel->r_addend = tocrel->r_addend;
9606                       elf_section_data (sec)->relocs = relstart;
9607                       continue;
9608                     }
9609
9610                   if (h != NULL || sym->st_value != 0)
9611                     continue;
9612
9613                   rel->r_addend -= skip[val >> 3];
9614                   elf_section_data (sec)->relocs = relstart;
9615                 }
9616
9617               if (elf_section_data (sec)->relocs != relstart)
9618                 free (relstart);
9619             }
9620
9621           /* We shouldn't have local or global symbols defined in the TOC,
9622              but handle them anyway.  */
9623           if (local_syms != NULL)
9624             for (sym = local_syms;
9625                  sym < local_syms + symtab_hdr->sh_info;
9626                  ++sym)
9627               if (sym->st_value != 0
9628                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9629                 {
9630                   unsigned long i;
9631
9632                   if (sym->st_value > toc->rawsize)
9633                     i = toc->rawsize >> 3;
9634                   else
9635                     i = sym->st_value >> 3;
9636
9637                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9638                     {
9639                       if (local_toc_syms)
9640                         _bfd_error_handler
9641                           (_("%s defined on removed toc entry"),
9642                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9643                       do
9644                         ++i;
9645                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9646                       sym->st_value = (bfd_vma) i << 3;
9647                     }
9648
9649                   sym->st_value -= skip[i];
9650                   symtab_hdr->contents = (unsigned char *) local_syms;
9651                 }
9652
9653           /* Adjust any global syms defined in this toc input section.  */
9654           if (toc_inf.global_toc_syms)
9655             {
9656               toc_inf.toc = toc;
9657               toc_inf.skip = skip;
9658               toc_inf.global_toc_syms = FALSE;
9659               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9660                                       &toc_inf);
9661             }
9662
9663           if (toc->reloc_count != 0)
9664             {
9665               Elf_Internal_Shdr *rel_hdr;
9666               Elf_Internal_Rela *wrel;
9667               bfd_size_type sz;
9668
9669               /* Remove unused toc relocs, and adjust those we keep.  */
9670               if (toc_relocs == NULL)
9671                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9672                                                         info->keep_memory);
9673               if (toc_relocs == NULL)
9674                 goto error_ret;
9675
9676               wrel = toc_relocs;
9677               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9678                 if ((skip[rel->r_offset >> 3]
9679                      & (ref_from_discarded | can_optimize)) == 0)
9680                   {
9681                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9682                     wrel->r_info = rel->r_info;
9683                     wrel->r_addend = rel->r_addend;
9684                     ++wrel;
9685                   }
9686                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9687                                             &local_syms, NULL, NULL))
9688                   goto error_ret;
9689
9690               elf_section_data (toc)->relocs = toc_relocs;
9691               toc->reloc_count = wrel - toc_relocs;
9692               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9693               sz = rel_hdr->sh_entsize;
9694               rel_hdr->sh_size = toc->reloc_count * sz;
9695             }
9696         }
9697       else if (toc_relocs != NULL
9698                && elf_section_data (toc)->relocs != toc_relocs)
9699         free (toc_relocs);
9700
9701       if (local_syms != NULL
9702           && symtab_hdr->contents != (unsigned char *) local_syms)
9703         {
9704           if (!info->keep_memory)
9705             free (local_syms);
9706           else
9707             symtab_hdr->contents = (unsigned char *) local_syms;
9708         }
9709       free (skip);
9710     }
9711
9712   return TRUE;
9713 }
9714
9715 /* Return true iff input section I references the TOC using
9716    instructions limited to +/-32k offsets.  */
9717
9718 bfd_boolean
9719 ppc64_elf_has_small_toc_reloc (asection *i)
9720 {
9721   return (is_ppc64_elf (i->owner)
9722           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9723 }
9724
9725 /* Allocate space for one GOT entry.  */
9726
9727 static void
9728 allocate_got (struct elf_link_hash_entry *h,
9729               struct bfd_link_info *info,
9730               struct got_entry *gent)
9731 {
9732   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9733   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9734   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9735                  ? 16 : 8);
9736   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9737                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9738   asection *got = ppc64_elf_tdata (gent->owner)->got;
9739
9740   gent->got.offset = got->size;
9741   got->size += entsize;
9742
9743   if (h->type == STT_GNU_IFUNC)
9744     {
9745       htab->elf.irelplt->size += rentsize;
9746       htab->got_reli_size += rentsize;
9747     }
9748   else if ((bfd_link_pic (info)
9749             || (htab->elf.dynamic_sections_created
9750                 && h->dynindx != -1
9751                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9752            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9753     {
9754       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9755       relgot->size += rentsize;
9756     }
9757 }
9758
9759 /* This function merges got entries in the same toc group.  */
9760
9761 static void
9762 merge_got_entries (struct got_entry **pent)
9763 {
9764   struct got_entry *ent, *ent2;
9765
9766   for (ent = *pent; ent != NULL; ent = ent->next)
9767     if (!ent->is_indirect)
9768       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9769         if (!ent2->is_indirect
9770             && ent2->addend == ent->addend
9771             && ent2->tls_type == ent->tls_type
9772             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9773           {
9774             ent2->is_indirect = TRUE;
9775             ent2->got.ent = ent;
9776           }
9777 }
9778
9779 /* If H is undefined, make it dynamic if that makes sense.  */
9780
9781 static bfd_boolean
9782 ensure_undef_dynamic (struct bfd_link_info *info,
9783                       struct elf_link_hash_entry *h)
9784 {
9785   struct elf_link_hash_table *htab = elf_hash_table (info);
9786
9787   if (htab->dynamic_sections_created
9788       && ((info->dynamic_undefined_weak != 0
9789            && h->root.type == bfd_link_hash_undefweak)
9790           || h->root.type == bfd_link_hash_undefined)
9791       && h->dynindx == -1
9792       && !h->forced_local
9793       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9794     return bfd_elf_link_record_dynamic_symbol (info, h);
9795   return TRUE;
9796 }
9797
9798 /* Allocate space in .plt, .got and associated reloc sections for
9799    dynamic relocs.  */
9800
9801 static bfd_boolean
9802 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9803 {
9804   struct bfd_link_info *info;
9805   struct ppc_link_hash_table *htab;
9806   asection *s;
9807   struct ppc_link_hash_entry *eh;
9808   struct got_entry **pgent, *gent;
9809
9810   if (h->root.type == bfd_link_hash_indirect)
9811     return TRUE;
9812
9813   info = (struct bfd_link_info *) inf;
9814   htab = ppc_hash_table (info);
9815   if (htab == NULL)
9816     return FALSE;
9817
9818   eh = (struct ppc_link_hash_entry *) h;
9819   /* Run through the TLS GD got entries first if we're changing them
9820      to TPREL.  */
9821   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9822     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9823       if (gent->got.refcount > 0
9824           && (gent->tls_type & TLS_GD) != 0)
9825         {
9826           /* This was a GD entry that has been converted to TPREL.  If
9827              there happens to be a TPREL entry we can use that one.  */
9828           struct got_entry *ent;
9829           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9830             if (ent->got.refcount > 0
9831                 && (ent->tls_type & TLS_TPREL) != 0
9832                 && ent->addend == gent->addend
9833                 && ent->owner == gent->owner)
9834               {
9835                 gent->got.refcount = 0;
9836                 break;
9837               }
9838
9839           /* If not, then we'll be using our own TPREL entry.  */
9840           if (gent->got.refcount != 0)
9841             gent->tls_type = TLS_TLS | TLS_TPREL;
9842         }
9843
9844   /* Remove any list entry that won't generate a word in the GOT before
9845      we call merge_got_entries.  Otherwise we risk merging to empty
9846      entries.  */
9847   pgent = &h->got.glist;
9848   while ((gent = *pgent) != NULL)
9849     if (gent->got.refcount > 0)
9850       {
9851         if ((gent->tls_type & TLS_LD) != 0
9852             && !h->def_dynamic)
9853           {
9854             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9855             *pgent = gent->next;
9856           }
9857         else
9858           pgent = &gent->next;
9859       }
9860     else
9861       *pgent = gent->next;
9862
9863   if (!htab->do_multi_toc)
9864     merge_got_entries (&h->got.glist);
9865
9866   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9867     if (!gent->is_indirect)
9868       {
9869         /* Make sure this symbol is output as a dynamic symbol.  */
9870         if (!ensure_undef_dynamic (info, h))
9871           return FALSE;
9872
9873         if (!is_ppc64_elf (gent->owner))
9874           abort ();
9875
9876         allocate_got (h, info, gent);
9877       }
9878
9879   /* If no dynamic sections we can't have dynamic relocs, except for
9880      IFUNCs which are handled even in static executables.  */
9881   if (!htab->elf.dynamic_sections_created
9882       && h->type != STT_GNU_IFUNC)
9883     eh->dyn_relocs = NULL;
9884
9885   /* Also discard relocs on undefined weak syms with non-default
9886      visibility, or when dynamic_undefined_weak says so.  */
9887   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9888     eh->dyn_relocs = NULL;
9889
9890   if (eh->dyn_relocs != NULL)
9891     {
9892       struct elf_dyn_relocs *p, **pp;
9893
9894       /* In the shared -Bsymbolic case, discard space allocated for
9895          dynamic pc-relative relocs against symbols which turn out to
9896          be defined in regular objects.  For the normal shared case,
9897          discard space for relocs that have become local due to symbol
9898          visibility changes.  */
9899
9900       if (bfd_link_pic (info))
9901         {
9902           /* Relocs that use pc_count are those that appear on a call
9903              insn, or certain REL relocs (see must_be_dyn_reloc) that
9904              can be generated via assembly.  We want calls to
9905              protected symbols to resolve directly to the function
9906              rather than going via the plt.  If people want function
9907              pointer comparisons to work as expected then they should
9908              avoid writing weird assembly.  */
9909           if (SYMBOL_CALLS_LOCAL (info, h))
9910             {
9911               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9912                 {
9913                   p->count -= p->pc_count;
9914                   p->pc_count = 0;
9915                   if (p->count == 0)
9916                     *pp = p->next;
9917                   else
9918                     pp = &p->next;
9919                 }
9920             }
9921
9922           if (eh->dyn_relocs != NULL)
9923             {
9924               /* Make sure this symbol is output as a dynamic symbol.  */
9925               if (!ensure_undef_dynamic (info, h))
9926                 return FALSE;
9927             }
9928         }
9929       else if (h->type == STT_GNU_IFUNC)
9930         {
9931           /* A plt entry is always created when making direct calls to
9932              an ifunc, even when building a static executable, but
9933              that doesn't cover all cases.  We may have only an ifunc
9934              initialised function pointer for a given ifunc symbol.
9935
9936              For ELFv2, dynamic relocations are not required when
9937              generating a global entry PLT stub.  */
9938           if (abiversion (info->output_bfd) >= 2)
9939             {
9940               if (global_entry_stub (h))
9941                 eh->dyn_relocs = NULL;
9942             }
9943
9944           /* For ELFv1 we have function descriptors.  Descriptors need
9945              to be treated like PLT entries and thus have dynamic
9946              relocations.  One exception is when the function
9947              descriptor is copied into .dynbss (which should only
9948              happen with ancient versions of gcc).  */
9949           else if (h->needs_copy)
9950             eh->dyn_relocs = NULL;
9951         }
9952       else if (ELIMINATE_COPY_RELOCS)
9953         {
9954           /* For the non-pic case, discard space for relocs against
9955              symbols which turn out to need copy relocs or are not
9956              dynamic.  */
9957           if (!h->non_got_ref
9958               && !h->def_regular)
9959             {
9960               /* Make sure this symbol is output as a dynamic symbol.  */
9961               if (!ensure_undef_dynamic (info, h))
9962                 return FALSE;
9963
9964               if (h->dynindx == -1)
9965                 eh->dyn_relocs = NULL;
9966             }
9967           else
9968             eh->dyn_relocs = NULL;
9969         }
9970
9971       /* Finally, allocate space.  */
9972       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9973         {
9974           asection *sreloc = elf_section_data (p->sec)->sreloc;
9975           if (eh->elf.type == STT_GNU_IFUNC)
9976             sreloc = htab->elf.irelplt;
9977           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9978         }
9979     }
9980
9981   if ((htab->elf.dynamic_sections_created
9982        && h->dynindx != -1)
9983       || h->type == STT_GNU_IFUNC)
9984     {
9985       struct plt_entry *pent;
9986       bfd_boolean doneone = FALSE;
9987       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9988         if (pent->plt.refcount > 0)
9989           {
9990             if (!htab->elf.dynamic_sections_created
9991                 || h->dynindx == -1)
9992               {
9993                 s = htab->elf.iplt;
9994                 pent->plt.offset = s->size;
9995                 s->size += PLT_ENTRY_SIZE (htab);
9996                 s = htab->elf.irelplt;
9997               }
9998             else
9999               {
10000                 /* If this is the first .plt entry, make room for the special
10001                    first entry.  */
10002                 s = htab->elf.splt;
10003                 if (s->size == 0)
10004                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10005
10006                 pent->plt.offset = s->size;
10007
10008                 /* Make room for this entry.  */
10009                 s->size += PLT_ENTRY_SIZE (htab);
10010
10011                 /* Make room for the .glink code.  */
10012                 s = htab->glink;
10013                 if (s->size == 0)
10014                   s->size += GLINK_CALL_STUB_SIZE;
10015                 if (htab->opd_abi)
10016                   {
10017                     /* We need bigger stubs past index 32767.  */
10018                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
10019                       s->size += 4;
10020                     s->size += 2*4;
10021                   }
10022                 else
10023                   s->size += 4;
10024
10025                 /* We also need to make an entry in the .rela.plt section.  */
10026                 s = htab->elf.srelplt;
10027               }
10028             s->size += sizeof (Elf64_External_Rela);
10029             doneone = TRUE;
10030           }
10031         else
10032           pent->plt.offset = (bfd_vma) -1;
10033       if (!doneone)
10034         {
10035           h->plt.plist = NULL;
10036           h->needs_plt = 0;
10037         }
10038     }
10039   else
10040     {
10041       h->plt.plist = NULL;
10042       h->needs_plt = 0;
10043     }
10044
10045   return TRUE;
10046 }
10047
10048 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10049    to set up space for global entry stubs.  These are put in glink,
10050    after the branch table.  */
10051
10052 static bfd_boolean
10053 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10054 {
10055   struct bfd_link_info *info;
10056   struct ppc_link_hash_table *htab;
10057   struct plt_entry *pent;
10058   asection *s;
10059
10060   if (h->root.type == bfd_link_hash_indirect)
10061     return TRUE;
10062
10063   if (!h->pointer_equality_needed)
10064     return TRUE;
10065
10066   if (h->def_regular)
10067     return TRUE;
10068
10069   info = inf;
10070   htab = ppc_hash_table (info);
10071   if (htab == NULL)
10072     return FALSE;
10073
10074   s = htab->glink;
10075   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10076     if (pent->plt.offset != (bfd_vma) -1
10077         && pent->addend == 0)
10078       {
10079         /* For ELFv2, if this symbol is not defined in a regular file
10080            and we are not generating a shared library or pie, then we
10081            need to define the symbol in the executable on a call stub.
10082            This is to avoid text relocations.  */
10083         s->size = (s->size + 15) & -16;
10084         h->root.type = bfd_link_hash_defined;
10085         h->root.u.def.section = s;
10086         h->root.u.def.value = s->size;
10087         s->size += 16;
10088         break;
10089       }
10090   return TRUE;
10091 }
10092
10093 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10094    read-only sections.  */
10095
10096 static bfd_boolean
10097 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10098 {
10099   if (h->root.type == bfd_link_hash_indirect)
10100     return TRUE;
10101
10102   if (readonly_dynrelocs (h))
10103     {
10104       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10105
10106       /* Not an error, just cut short the traversal.  */
10107       return FALSE;
10108     }
10109   return TRUE;
10110 }
10111
10112 /* Set the sizes of the dynamic sections.  */
10113
10114 static bfd_boolean
10115 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10116                                  struct bfd_link_info *info)
10117 {
10118   struct ppc_link_hash_table *htab;
10119   bfd *dynobj;
10120   asection *s;
10121   bfd_boolean relocs;
10122   bfd *ibfd;
10123   struct got_entry *first_tlsld;
10124
10125   htab = ppc_hash_table (info);
10126   if (htab == NULL)
10127     return FALSE;
10128
10129   dynobj = htab->elf.dynobj;
10130   if (dynobj == NULL)
10131     abort ();
10132
10133   if (htab->elf.dynamic_sections_created)
10134     {
10135       /* Set the contents of the .interp section to the interpreter.  */
10136       if (bfd_link_executable (info) && !info->nointerp)
10137         {
10138           s = bfd_get_linker_section (dynobj, ".interp");
10139           if (s == NULL)
10140             abort ();
10141           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10142           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10143         }
10144     }
10145
10146   /* Set up .got offsets for local syms, and space for local dynamic
10147      relocs.  */
10148   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10149     {
10150       struct got_entry **lgot_ents;
10151       struct got_entry **end_lgot_ents;
10152       struct plt_entry **local_plt;
10153       struct plt_entry **end_local_plt;
10154       unsigned char *lgot_masks;
10155       bfd_size_type locsymcount;
10156       Elf_Internal_Shdr *symtab_hdr;
10157
10158       if (!is_ppc64_elf (ibfd))
10159         continue;
10160
10161       for (s = ibfd->sections; s != NULL; s = s->next)
10162         {
10163           struct ppc_dyn_relocs *p;
10164
10165           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10166             {
10167               if (!bfd_is_abs_section (p->sec)
10168                   && bfd_is_abs_section (p->sec->output_section))
10169                 {
10170                   /* Input section has been discarded, either because
10171                      it is a copy of a linkonce section or due to
10172                      linker script /DISCARD/, so we'll be discarding
10173                      the relocs too.  */
10174                 }
10175               else if (p->count != 0)
10176                 {
10177                   asection *srel = elf_section_data (p->sec)->sreloc;
10178                   if (p->ifunc)
10179                     srel = htab->elf.irelplt;
10180                   srel->size += p->count * sizeof (Elf64_External_Rela);
10181                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10182                     info->flags |= DF_TEXTREL;
10183                 }
10184             }
10185         }
10186
10187       lgot_ents = elf_local_got_ents (ibfd);
10188       if (!lgot_ents)
10189         continue;
10190
10191       symtab_hdr = &elf_symtab_hdr (ibfd);
10192       locsymcount = symtab_hdr->sh_info;
10193       end_lgot_ents = lgot_ents + locsymcount;
10194       local_plt = (struct plt_entry **) end_lgot_ents;
10195       end_local_plt = local_plt + locsymcount;
10196       lgot_masks = (unsigned char *) end_local_plt;
10197       s = ppc64_elf_tdata (ibfd)->got;
10198       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10199         {
10200           struct got_entry **pent, *ent;
10201
10202           pent = lgot_ents;
10203           while ((ent = *pent) != NULL)
10204             if (ent->got.refcount > 0)
10205               {
10206                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10207                   {
10208                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10209                     *pent = ent->next;
10210                   }
10211                 else
10212                   {
10213                     unsigned int ent_size = 8;
10214                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10215
10216                     ent->got.offset = s->size;
10217                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10218                       {
10219                         ent_size *= 2;
10220                         rel_size *= 2;
10221                       }
10222                     s->size += ent_size;
10223                     if ((*lgot_masks & PLT_IFUNC) != 0)
10224                       {
10225                         htab->elf.irelplt->size += rel_size;
10226                         htab->got_reli_size += rel_size;
10227                       }
10228                     else if (bfd_link_pic (info))
10229                       {
10230                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10231                         srel->size += rel_size;
10232                       }
10233                     pent = &ent->next;
10234                   }
10235               }
10236             else
10237               *pent = ent->next;
10238         }
10239
10240       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10241       for (; local_plt < end_local_plt; ++local_plt)
10242         {
10243           struct plt_entry *ent;
10244
10245           for (ent = *local_plt; ent != NULL; ent = ent->next)
10246             if (ent->plt.refcount > 0)
10247               {
10248                 s = htab->elf.iplt;
10249                 ent->plt.offset = s->size;
10250                 s->size += PLT_ENTRY_SIZE (htab);
10251
10252                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10253               }
10254             else
10255               ent->plt.offset = (bfd_vma) -1;
10256         }
10257     }
10258
10259   /* Allocate global sym .plt and .got entries, and space for global
10260      sym dynamic relocs.  */
10261   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10262   /* Stash the end of glink branch table.  */
10263   if (htab->glink != NULL)
10264     htab->glink->rawsize = htab->glink->size;
10265
10266   if (!htab->opd_abi && !bfd_link_pic (info))
10267     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10268
10269   first_tlsld = NULL;
10270   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10271     {
10272       struct got_entry *ent;
10273
10274       if (!is_ppc64_elf (ibfd))
10275         continue;
10276
10277       ent = ppc64_tlsld_got (ibfd);
10278       if (ent->got.refcount > 0)
10279         {
10280           if (!htab->do_multi_toc && first_tlsld != NULL)
10281             {
10282               ent->is_indirect = TRUE;
10283               ent->got.ent = first_tlsld;
10284             }
10285           else
10286             {
10287               if (first_tlsld == NULL)
10288                 first_tlsld = ent;
10289               s = ppc64_elf_tdata (ibfd)->got;
10290               ent->got.offset = s->size;
10291               ent->owner = ibfd;
10292               s->size += 16;
10293               if (bfd_link_pic (info))
10294                 {
10295                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10296                   srel->size += sizeof (Elf64_External_Rela);
10297                 }
10298             }
10299         }
10300       else
10301         ent->got.offset = (bfd_vma) -1;
10302     }
10303
10304   /* We now have determined the sizes of the various dynamic sections.
10305      Allocate memory for them.  */
10306   relocs = FALSE;
10307   for (s = dynobj->sections; s != NULL; s = s->next)
10308     {
10309       if ((s->flags & SEC_LINKER_CREATED) == 0)
10310         continue;
10311
10312       if (s == htab->brlt || s == htab->relbrlt)
10313         /* These haven't been allocated yet;  don't strip.  */
10314         continue;
10315       else if (s == htab->elf.sgot
10316                || s == htab->elf.splt
10317                || s == htab->elf.iplt
10318                || s == htab->glink
10319                || s == htab->elf.sdynbss
10320                || s == htab->elf.sdynrelro)
10321         {
10322           /* Strip this section if we don't need it; see the
10323              comment below.  */
10324         }
10325       else if (s == htab->glink_eh_frame)
10326         {
10327           if (!bfd_is_abs_section (s->output_section))
10328             /* Not sized yet.  */
10329             continue;
10330         }
10331       else if (CONST_STRNEQ (s->name, ".rela"))
10332         {
10333           if (s->size != 0)
10334             {
10335               if (s != htab->elf.srelplt)
10336                 relocs = TRUE;
10337
10338               /* We use the reloc_count field as a counter if we need
10339                  to copy relocs into the output file.  */
10340               s->reloc_count = 0;
10341             }
10342         }
10343       else
10344         {
10345           /* It's not one of our sections, so don't allocate space.  */
10346           continue;
10347         }
10348
10349       if (s->size == 0)
10350         {
10351           /* If we don't need this section, strip it from the
10352              output file.  This is mostly to handle .rela.bss and
10353              .rela.plt.  We must create both sections in
10354              create_dynamic_sections, because they must be created
10355              before the linker maps input sections to output
10356              sections.  The linker does that before
10357              adjust_dynamic_symbol is called, and it is that
10358              function which decides whether anything needs to go
10359              into these sections.  */
10360           s->flags |= SEC_EXCLUDE;
10361           continue;
10362         }
10363
10364       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10365         continue;
10366
10367       /* Allocate memory for the section contents.  We use bfd_zalloc
10368          here in case unused entries are not reclaimed before the
10369          section's contents are written out.  This should not happen,
10370          but this way if it does we get a R_PPC64_NONE reloc in .rela
10371          sections instead of garbage.
10372          We also rely on the section contents being zero when writing
10373          the GOT and .dynrelro.  */
10374       s->contents = bfd_zalloc (dynobj, s->size);
10375       if (s->contents == NULL)
10376         return FALSE;
10377     }
10378
10379   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10380     {
10381       if (!is_ppc64_elf (ibfd))
10382         continue;
10383
10384       s = ppc64_elf_tdata (ibfd)->got;
10385       if (s != NULL && s != htab->elf.sgot)
10386         {
10387           if (s->size == 0)
10388             s->flags |= SEC_EXCLUDE;
10389           else
10390             {
10391               s->contents = bfd_zalloc (ibfd, s->size);
10392               if (s->contents == NULL)
10393                 return FALSE;
10394             }
10395         }
10396       s = ppc64_elf_tdata (ibfd)->relgot;
10397       if (s != NULL)
10398         {
10399           if (s->size == 0)
10400             s->flags |= SEC_EXCLUDE;
10401           else
10402             {
10403               s->contents = bfd_zalloc (ibfd, s->size);
10404               if (s->contents == NULL)
10405                 return FALSE;
10406               relocs = TRUE;
10407               s->reloc_count = 0;
10408             }
10409         }
10410     }
10411
10412   if (htab->elf.dynamic_sections_created)
10413     {
10414       bfd_boolean tls_opt;
10415
10416       /* Add some entries to the .dynamic section.  We fill in the
10417          values later, in ppc64_elf_finish_dynamic_sections, but we
10418          must add the entries now so that we get the correct size for
10419          the .dynamic section.  The DT_DEBUG entry is filled in by the
10420          dynamic linker and used by the debugger.  */
10421 #define add_dynamic_entry(TAG, VAL) \
10422   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10423
10424       if (bfd_link_executable (info))
10425         {
10426           if (!add_dynamic_entry (DT_DEBUG, 0))
10427             return FALSE;
10428         }
10429
10430       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10431         {
10432           if (!add_dynamic_entry (DT_PLTGOT, 0)
10433               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10434               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10435               || !add_dynamic_entry (DT_JMPREL, 0)
10436               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10437             return FALSE;
10438         }
10439
10440       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10441         {
10442           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10443               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10444             return FALSE;
10445         }
10446
10447       tls_opt = (htab->params->tls_get_addr_opt
10448                  && htab->tls_get_addr_fd != NULL
10449                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10450       if (tls_opt || !htab->opd_abi)
10451         {
10452           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10453             return FALSE;
10454         }
10455
10456       if (relocs)
10457         {
10458           if (!add_dynamic_entry (DT_RELA, 0)
10459               || !add_dynamic_entry (DT_RELASZ, 0)
10460               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10461             return FALSE;
10462
10463           /* If any dynamic relocs apply to a read-only section,
10464              then we need a DT_TEXTREL entry.  */
10465           if ((info->flags & DF_TEXTREL) == 0)
10466             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10467
10468           if ((info->flags & DF_TEXTREL) != 0)
10469             {
10470               if (!add_dynamic_entry (DT_TEXTREL, 0))
10471                 return FALSE;
10472             }
10473         }
10474     }
10475 #undef add_dynamic_entry
10476
10477   return TRUE;
10478 }
10479
10480 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10481
10482 static bfd_boolean
10483 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10484 {
10485   if (h->plt.plist != NULL
10486       && !h->def_regular
10487       && !h->pointer_equality_needed)
10488     return FALSE;
10489
10490   return _bfd_elf_hash_symbol (h);
10491 }
10492
10493 /* Determine the type of stub needed, if any, for a call.  */
10494
10495 static inline enum ppc_stub_type
10496 ppc_type_of_stub (asection *input_sec,
10497                   const Elf_Internal_Rela *rel,
10498                   struct ppc_link_hash_entry **hash,
10499                   struct plt_entry **plt_ent,
10500                   bfd_vma destination,
10501                   unsigned long local_off)
10502 {
10503   struct ppc_link_hash_entry *h = *hash;
10504   bfd_vma location;
10505   bfd_vma branch_offset;
10506   bfd_vma max_branch_offset;
10507   enum elf_ppc64_reloc_type r_type;
10508
10509   if (h != NULL)
10510     {
10511       struct plt_entry *ent;
10512       struct ppc_link_hash_entry *fdh = h;
10513       if (h->oh != NULL
10514           && h->oh->is_func_descriptor)
10515         {
10516           fdh = ppc_follow_link (h->oh);
10517           *hash = fdh;
10518         }
10519
10520       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10521         if (ent->addend == rel->r_addend
10522             && ent->plt.offset != (bfd_vma) -1)
10523           {
10524             *plt_ent = ent;
10525             return ppc_stub_plt_call;
10526           }
10527
10528       /* Here, we know we don't have a plt entry.  If we don't have a
10529          either a defined function descriptor or a defined entry symbol
10530          in a regular object file, then it is pointless trying to make
10531          any other type of stub.  */
10532       if (!is_static_defined (&fdh->elf)
10533           && !is_static_defined (&h->elf))
10534         return ppc_stub_none;
10535     }
10536   else if (elf_local_got_ents (input_sec->owner) != NULL)
10537     {
10538       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10539       struct plt_entry **local_plt = (struct plt_entry **)
10540         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10541       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10542
10543       if (local_plt[r_symndx] != NULL)
10544         {
10545           struct plt_entry *ent;
10546
10547           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10548             if (ent->addend == rel->r_addend
10549                 && ent->plt.offset != (bfd_vma) -1)
10550               {
10551                 *plt_ent = ent;
10552                 return ppc_stub_plt_call;
10553               }
10554         }
10555     }
10556
10557   /* Determine where the call point is.  */
10558   location = (input_sec->output_offset
10559               + input_sec->output_section->vma
10560               + rel->r_offset);
10561
10562   branch_offset = destination - location;
10563   r_type = ELF64_R_TYPE (rel->r_info);
10564
10565   /* Determine if a long branch stub is needed.  */
10566   max_branch_offset = 1 << 25;
10567   if (r_type != R_PPC64_REL24)
10568     max_branch_offset = 1 << 15;
10569
10570   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10571     /* We need a stub.  Figure out whether a long_branch or plt_branch
10572        is needed later.  */
10573     return ppc_stub_long_branch;
10574
10575   return ppc_stub_none;
10576 }
10577
10578 /* With power7 weakly ordered memory model, it is possible for ld.so
10579    to update a plt entry in one thread and have another thread see a
10580    stale zero toc entry.  To avoid this we need some sort of acquire
10581    barrier in the call stub.  One solution is to make the load of the
10582    toc word seem to appear to depend on the load of the function entry
10583    word.  Another solution is to test for r2 being zero, and branch to
10584    the appropriate glink entry if so.
10585
10586    .    fake dep barrier        compare
10587    .    ld 12,xxx(2)            ld 12,xxx(2)
10588    .    mtctr 12                mtctr 12
10589    .    xor 11,12,12            ld 2,xxx+8(2)
10590    .    add 2,2,11              cmpldi 2,0
10591    .    ld 2,xxx+8(2)           bnectr+
10592    .    bctr                    b <glink_entry>
10593
10594    The solution involving the compare turns out to be faster, so
10595    that's what we use unless the branch won't reach.  */
10596
10597 #define ALWAYS_USE_FAKE_DEP 0
10598 #define ALWAYS_EMIT_R2SAVE 0
10599
10600 #define PPC_LO(v) ((v) & 0xffff)
10601 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10602 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10603
10604 static inline unsigned int
10605 plt_stub_size (struct ppc_link_hash_table *htab,
10606                struct ppc_stub_hash_entry *stub_entry,
10607                bfd_vma off)
10608 {
10609   unsigned size = 12;
10610
10611   if (ALWAYS_EMIT_R2SAVE
10612       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10613     size += 4;
10614   if (PPC_HA (off) != 0)
10615     size += 4;
10616   if (htab->opd_abi)
10617     {
10618       size += 4;
10619       if (htab->params->plt_static_chain)
10620         size += 4;
10621       if (htab->params->plt_thread_safe
10622           && htab->elf.dynamic_sections_created
10623           && stub_entry->h != NULL
10624           && stub_entry->h->elf.dynindx != -1)
10625         size += 8;
10626       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10627         size += 4;
10628     }
10629   if (stub_entry->h != NULL
10630       && (stub_entry->h == htab->tls_get_addr_fd
10631           || stub_entry->h == htab->tls_get_addr)
10632       && htab->params->tls_get_addr_opt)
10633     {
10634       size += 7 * 4;
10635       if (ALWAYS_EMIT_R2SAVE
10636           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10637         size += 6 * 4;
10638     }
10639   return size;
10640 }
10641
10642 /* Depending on the sign of plt_stub_align:
10643    If positive, return the padding to align to a 2**plt_stub_align
10644    boundary.
10645    If negative, if this stub would cross fewer 2**plt_stub_align
10646    boundaries if we align, then return the padding needed to do so.  */
10647
10648 static inline unsigned int
10649 plt_stub_pad (struct ppc_link_hash_table *htab,
10650               struct ppc_stub_hash_entry *stub_entry,
10651               bfd_vma plt_off)
10652 {
10653   int stub_align;
10654   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10655   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10656
10657   if (htab->params->plt_stub_align >= 0)
10658     {
10659       stub_align = 1 << htab->params->plt_stub_align;
10660       if ((stub_off & (stub_align - 1)) != 0)
10661         return stub_align - (stub_off & (stub_align - 1));
10662       return 0;
10663     }
10664
10665   stub_align = 1 << -htab->params->plt_stub_align;
10666   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10667       > ((stub_size - 1) & -stub_align))
10668     return stub_align - (stub_off & (stub_align - 1));
10669   return 0;
10670 }
10671
10672 /* Build a .plt call stub.  */
10673
10674 static inline bfd_byte *
10675 build_plt_stub (struct ppc_link_hash_table *htab,
10676                 struct ppc_stub_hash_entry *stub_entry,
10677                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10678 {
10679   bfd *obfd = htab->params->stub_bfd;
10680   bfd_boolean plt_load_toc = htab->opd_abi;
10681   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10682   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10683                                  && htab->elf.dynamic_sections_created
10684                                  && stub_entry->h != NULL
10685                                  && stub_entry->h->elf.dynindx != -1);
10686   bfd_boolean use_fake_dep = plt_thread_safe;
10687   bfd_vma cmp_branch_off = 0;
10688
10689   if (!ALWAYS_USE_FAKE_DEP
10690       && plt_load_toc
10691       && plt_thread_safe
10692       && !((stub_entry->h == htab->tls_get_addr_fd
10693             || stub_entry->h == htab->tls_get_addr)
10694            && htab->params->tls_get_addr_opt))
10695     {
10696       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10697       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10698                           / PLT_ENTRY_SIZE (htab));
10699       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10700       bfd_vma to, from;
10701
10702       if (pltindex > 32768)
10703         glinkoff += (pltindex - 32768) * 4;
10704       to = (glinkoff
10705             + htab->glink->output_offset
10706             + htab->glink->output_section->vma);
10707       from = (p - stub_entry->group->stub_sec->contents
10708               + 4 * (ALWAYS_EMIT_R2SAVE
10709                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10710               + 4 * (PPC_HA (offset) != 0)
10711               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10712                      != PPC_HA (offset))
10713               + 4 * (plt_static_chain != 0)
10714               + 20
10715               + stub_entry->group->stub_sec->output_offset
10716               + stub_entry->group->stub_sec->output_section->vma);
10717       cmp_branch_off = to - from;
10718       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10719     }
10720
10721   if (PPC_HA (offset) != 0)
10722     {
10723       if (r != NULL)
10724         {
10725           if (ALWAYS_EMIT_R2SAVE
10726               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10727             r[0].r_offset += 4;
10728           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10729           r[1].r_offset = r[0].r_offset + 4;
10730           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10731           r[1].r_addend = r[0].r_addend;
10732           if (plt_load_toc)
10733             {
10734               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10735                 {
10736                   r[2].r_offset = r[1].r_offset + 4;
10737                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10738                   r[2].r_addend = r[0].r_addend;
10739                 }
10740               else
10741                 {
10742                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10743                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10744                   r[2].r_addend = r[0].r_addend + 8;
10745                   if (plt_static_chain)
10746                     {
10747                       r[3].r_offset = r[2].r_offset + 4;
10748                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10749                       r[3].r_addend = r[0].r_addend + 16;
10750                     }
10751                 }
10752             }
10753         }
10754       if (ALWAYS_EMIT_R2SAVE
10755           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10756         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10757       if (plt_load_toc)
10758         {
10759           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10760           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10761         }
10762       else
10763         {
10764           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10765           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10766         }
10767       if (plt_load_toc
10768           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10769         {
10770           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10771           offset = 0;
10772         }
10773       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10774       if (plt_load_toc)
10775         {
10776           if (use_fake_dep)
10777             {
10778               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10779               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10780             }
10781           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10782           if (plt_static_chain)
10783             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10784         }
10785     }
10786   else
10787     {
10788       if (r != NULL)
10789         {
10790           if (ALWAYS_EMIT_R2SAVE
10791               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10792             r[0].r_offset += 4;
10793           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10794           if (plt_load_toc)
10795             {
10796               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10797                 {
10798                   r[1].r_offset = r[0].r_offset + 4;
10799                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10800                   r[1].r_addend = r[0].r_addend;
10801                 }
10802               else
10803                 {
10804                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10805                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10806                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10807                   if (plt_static_chain)
10808                     {
10809                       r[2].r_offset = r[1].r_offset + 4;
10810                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10811                       r[2].r_addend = r[0].r_addend + 8;
10812                     }
10813                 }
10814             }
10815         }
10816       if (ALWAYS_EMIT_R2SAVE
10817           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10818         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10819       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10820       if (plt_load_toc
10821           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10822         {
10823           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10824           offset = 0;
10825         }
10826       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10827       if (plt_load_toc)
10828         {
10829           if (use_fake_dep)
10830             {
10831               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10832               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10833             }
10834           if (plt_static_chain)
10835             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10836           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10837         }
10838     }
10839   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10840     {
10841       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10842       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10843       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10844     }
10845   else
10846     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10847   return p;
10848 }
10849
10850 /* Build a special .plt call stub for __tls_get_addr.  */
10851
10852 #define LD_R11_0R3      0xe9630000
10853 #define LD_R12_0R3      0xe9830000
10854 #define MR_R0_R3        0x7c601b78
10855 #define CMPDI_R11_0     0x2c2b0000
10856 #define ADD_R3_R12_R13  0x7c6c6a14
10857 #define BEQLR           0x4d820020
10858 #define MR_R3_R0        0x7c030378
10859 #define STD_R11_0R1     0xf9610000
10860 #define BCTRL           0x4e800421
10861 #define LD_R11_0R1      0xe9610000
10862 #define MTLR_R11        0x7d6803a6
10863
10864 static inline bfd_byte *
10865 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10866                          struct ppc_stub_hash_entry *stub_entry,
10867                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10868 {
10869   bfd *obfd = htab->params->stub_bfd;
10870
10871   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10872   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10873   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10874   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10875   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10876   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10877   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10878   if (r != NULL)
10879     r[0].r_offset += 7 * 4;
10880   if (!ALWAYS_EMIT_R2SAVE
10881       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10882     return build_plt_stub (htab, stub_entry, p, offset, r);
10883
10884   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10885   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10886
10887   if (r != NULL)
10888     r[0].r_offset += 2 * 4;
10889   p = build_plt_stub (htab, stub_entry, p, offset, r);
10890   bfd_put_32 (obfd, BCTRL, p - 4);
10891
10892   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10893   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10894   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10895   bfd_put_32 (obfd, BLR, p),                    p += 4;
10896
10897   return p;
10898 }
10899
10900 static Elf_Internal_Rela *
10901 get_relocs (asection *sec, int count)
10902 {
10903   Elf_Internal_Rela *relocs;
10904   struct bfd_elf_section_data *elfsec_data;
10905
10906   elfsec_data = elf_section_data (sec);
10907   relocs = elfsec_data->relocs;
10908   if (relocs == NULL)
10909     {
10910       bfd_size_type relsize;
10911       relsize = sec->reloc_count * sizeof (*relocs);
10912       relocs = bfd_alloc (sec->owner, relsize);
10913       if (relocs == NULL)
10914         return NULL;
10915       elfsec_data->relocs = relocs;
10916       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10917                                           sizeof (Elf_Internal_Shdr));
10918       if (elfsec_data->rela.hdr == NULL)
10919         return NULL;
10920       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10921                                         * sizeof (Elf64_External_Rela));
10922       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10923       sec->reloc_count = 0;
10924     }
10925   relocs += sec->reloc_count;
10926   sec->reloc_count += count;
10927   return relocs;
10928 }
10929
10930 static bfd_vma
10931 get_r2off (struct bfd_link_info *info,
10932            struct ppc_stub_hash_entry *stub_entry)
10933 {
10934   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10935   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10936
10937   if (r2off == 0)
10938     {
10939       /* Support linking -R objects.  Get the toc pointer from the
10940          opd entry.  */
10941       char buf[8];
10942       if (!htab->opd_abi)
10943         return r2off;
10944       asection *opd = stub_entry->h->elf.root.u.def.section;
10945       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10946
10947       if (strcmp (opd->name, ".opd") != 0
10948           || opd->reloc_count != 0)
10949         {
10950           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10951                                   stub_entry->h->elf.root.root.string);
10952           bfd_set_error (bfd_error_bad_value);
10953           return (bfd_vma) -1;
10954         }
10955       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10956         return (bfd_vma) -1;
10957       r2off = bfd_get_64 (opd->owner, buf);
10958       r2off -= elf_gp (info->output_bfd);
10959     }
10960   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10961   return r2off;
10962 }
10963
10964 static bfd_boolean
10965 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10966 {
10967   struct ppc_stub_hash_entry *stub_entry;
10968   struct ppc_branch_hash_entry *br_entry;
10969   struct bfd_link_info *info;
10970   struct ppc_link_hash_table *htab;
10971   bfd_byte *loc;
10972   bfd_byte *p;
10973   bfd_vma dest, off;
10974   int size;
10975   Elf_Internal_Rela *r;
10976   asection *plt;
10977
10978   /* Massage our args to the form they really have.  */
10979   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10980   info = in_arg;
10981
10982   htab = ppc_hash_table (info);
10983   if (htab == NULL)
10984     return FALSE;
10985
10986   /* Make a note of the offset within the stubs for this entry.  */
10987   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10988   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10989
10990   htab->stub_count[stub_entry->stub_type - 1] += 1;
10991   switch (stub_entry->stub_type)
10992     {
10993     case ppc_stub_long_branch:
10994     case ppc_stub_long_branch_r2off:
10995       /* Branches are relative.  This is where we are going to.  */
10996       dest = (stub_entry->target_value
10997               + stub_entry->target_section->output_offset
10998               + stub_entry->target_section->output_section->vma);
10999       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11000       off = dest;
11001
11002       /* And this is where we are coming from.  */
11003       off -= (stub_entry->stub_offset
11004               + stub_entry->group->stub_sec->output_offset
11005               + stub_entry->group->stub_sec->output_section->vma);
11006
11007       size = 4;
11008       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11009         {
11010           bfd_vma r2off = get_r2off (info, stub_entry);
11011
11012           if (r2off == (bfd_vma) -1)
11013             {
11014               htab->stub_error = TRUE;
11015               return FALSE;
11016             }
11017           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11018           loc += 4;
11019           size = 8;
11020           if (PPC_HA (r2off) != 0)
11021             {
11022               bfd_put_32 (htab->params->stub_bfd,
11023                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11024               loc += 4;
11025               size += 4;
11026             }
11027           if (PPC_LO (r2off) != 0)
11028             {
11029               bfd_put_32 (htab->params->stub_bfd,
11030                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11031               loc += 4;
11032               size += 4;
11033             }
11034           off -= size - 4;
11035         }
11036       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
11037
11038       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11039         {
11040           info->callbacks->einfo
11041             (_("%P: long branch stub `%s' offset overflow\n"),
11042              stub_entry->root.string);
11043           htab->stub_error = TRUE;
11044           return FALSE;
11045         }
11046
11047       if (info->emitrelocations)
11048         {
11049           r = get_relocs (stub_entry->group->stub_sec, 1);
11050           if (r == NULL)
11051             return FALSE;
11052           r->r_offset = loc - stub_entry->group->stub_sec->contents;
11053           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11054           r->r_addend = dest;
11055           if (stub_entry->h != NULL)
11056             {
11057               struct elf_link_hash_entry **hashes;
11058               unsigned long symndx;
11059               struct ppc_link_hash_entry *h;
11060
11061               hashes = elf_sym_hashes (htab->params->stub_bfd);
11062               if (hashes == NULL)
11063                 {
11064                   bfd_size_type hsize;
11065
11066                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11067                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11068                   if (hashes == NULL)
11069                     return FALSE;
11070                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
11071                   htab->stub_globals = 1;
11072                 }
11073               symndx = htab->stub_globals++;
11074               h = stub_entry->h;
11075               hashes[symndx] = &h->elf;
11076               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11077               if (h->oh != NULL && h->oh->is_func)
11078                 h = ppc_follow_link (h->oh);
11079               if (h->elf.root.u.def.section != stub_entry->target_section)
11080                 /* H is an opd symbol.  The addend must be zero.  */
11081                 r->r_addend = 0;
11082               else
11083                 {
11084                   off = (h->elf.root.u.def.value
11085                          + h->elf.root.u.def.section->output_offset
11086                          + h->elf.root.u.def.section->output_section->vma);
11087                   r->r_addend -= off;
11088                 }
11089             }
11090         }
11091       break;
11092
11093     case ppc_stub_plt_branch:
11094     case ppc_stub_plt_branch_r2off:
11095       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11096                                          stub_entry->root.string + 9,
11097                                          FALSE, FALSE);
11098       if (br_entry == NULL)
11099         {
11100           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
11101                                   stub_entry->root.string);
11102           htab->stub_error = TRUE;
11103           return FALSE;
11104         }
11105
11106       dest = (stub_entry->target_value
11107               + stub_entry->target_section->output_offset
11108               + stub_entry->target_section->output_section->vma);
11109       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11110         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11111
11112       bfd_put_64 (htab->brlt->owner, dest,
11113                   htab->brlt->contents + br_entry->offset);
11114
11115       if (br_entry->iter == htab->stub_iteration)
11116         {
11117           br_entry->iter = 0;
11118
11119           if (htab->relbrlt != NULL)
11120             {
11121               /* Create a reloc for the branch lookup table entry.  */
11122               Elf_Internal_Rela rela;
11123               bfd_byte *rl;
11124
11125               rela.r_offset = (br_entry->offset
11126                                + htab->brlt->output_offset
11127                                + htab->brlt->output_section->vma);
11128               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11129               rela.r_addend = dest;
11130
11131               rl = htab->relbrlt->contents;
11132               rl += (htab->relbrlt->reloc_count++
11133                      * sizeof (Elf64_External_Rela));
11134               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11135             }
11136           else if (info->emitrelocations)
11137             {
11138               r = get_relocs (htab->brlt, 1);
11139               if (r == NULL)
11140                 return FALSE;
11141               /* brlt, being SEC_LINKER_CREATED does not go through the
11142                  normal reloc processing.  Symbols and offsets are not
11143                  translated from input file to output file form, so
11144                  set up the offset per the output file.  */
11145               r->r_offset = (br_entry->offset
11146                              + htab->brlt->output_offset
11147                              + htab->brlt->output_section->vma);
11148               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11149               r->r_addend = dest;
11150             }
11151         }
11152
11153       dest = (br_entry->offset
11154               + htab->brlt->output_offset
11155               + htab->brlt->output_section->vma);
11156
11157       off = (dest
11158              - elf_gp (htab->brlt->output_section->owner)
11159              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11160
11161       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11162         {
11163           info->callbacks->einfo
11164             (_("%P: linkage table error against `%T'\n"),
11165              stub_entry->root.string);
11166           bfd_set_error (bfd_error_bad_value);
11167           htab->stub_error = TRUE;
11168           return FALSE;
11169         }
11170
11171       if (info->emitrelocations)
11172         {
11173           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11174           if (r == NULL)
11175             return FALSE;
11176           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11177           if (bfd_big_endian (info->output_bfd))
11178             r[0].r_offset += 2;
11179           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11180             r[0].r_offset += 4;
11181           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11182           r[0].r_addend = dest;
11183           if (PPC_HA (off) != 0)
11184             {
11185               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11186               r[1].r_offset = r[0].r_offset + 4;
11187               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11188               r[1].r_addend = r[0].r_addend;
11189             }
11190         }
11191
11192       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11193         {
11194           if (PPC_HA (off) != 0)
11195             {
11196               size = 16;
11197               bfd_put_32 (htab->params->stub_bfd,
11198                           ADDIS_R12_R2 | PPC_HA (off), loc);
11199               loc += 4;
11200               bfd_put_32 (htab->params->stub_bfd,
11201                           LD_R12_0R12 | PPC_LO (off), loc);
11202             }
11203           else
11204             {
11205               size = 12;
11206               bfd_put_32 (htab->params->stub_bfd,
11207                           LD_R12_0R2 | PPC_LO (off), loc);
11208             }
11209         }
11210       else
11211         {
11212           bfd_vma r2off = get_r2off (info, stub_entry);
11213
11214           if (r2off == (bfd_vma) -1)
11215             {
11216               htab->stub_error = TRUE;
11217               return FALSE;
11218             }
11219
11220           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11221           loc += 4;
11222           size = 16;
11223           if (PPC_HA (off) != 0)
11224             {
11225               size += 4;
11226               bfd_put_32 (htab->params->stub_bfd,
11227                           ADDIS_R12_R2 | PPC_HA (off), loc);
11228               loc += 4;
11229               bfd_put_32 (htab->params->stub_bfd,
11230                           LD_R12_0R12 | PPC_LO (off), loc);
11231             }
11232           else
11233             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11234
11235           if (PPC_HA (r2off) != 0)
11236             {
11237               size += 4;
11238               loc += 4;
11239               bfd_put_32 (htab->params->stub_bfd,
11240                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11241             }
11242           if (PPC_LO (r2off) != 0)
11243             {
11244               size += 4;
11245               loc += 4;
11246               bfd_put_32 (htab->params->stub_bfd,
11247                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11248             }
11249         }
11250       loc += 4;
11251       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11252       loc += 4;
11253       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11254       break;
11255
11256     case ppc_stub_plt_call:
11257     case ppc_stub_plt_call_r2save:
11258       if (stub_entry->h != NULL
11259           && stub_entry->h->is_func_descriptor
11260           && stub_entry->h->oh != NULL)
11261         {
11262           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11263
11264           /* If the old-ABI "dot-symbol" is undefined make it weak so
11265              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11266           if (fh->elf.root.type == bfd_link_hash_undefined
11267               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11268                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11269             fh->elf.root.type = bfd_link_hash_undefweak;
11270         }
11271
11272       /* Now build the stub.  */
11273       dest = stub_entry->plt_ent->plt.offset & ~1;
11274       if (dest >= (bfd_vma) -2)
11275         abort ();
11276
11277       plt = htab->elf.splt;
11278       if (!htab->elf.dynamic_sections_created
11279           || stub_entry->h == NULL
11280           || stub_entry->h->elf.dynindx == -1)
11281         plt = htab->elf.iplt;
11282
11283       dest += plt->output_offset + plt->output_section->vma;
11284
11285       if (stub_entry->h == NULL
11286           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11287         {
11288           Elf_Internal_Rela rela;
11289           bfd_byte *rl;
11290
11291           rela.r_offset = dest;
11292           if (htab->opd_abi)
11293             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11294           else
11295             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11296           rela.r_addend = (stub_entry->target_value
11297                            + stub_entry->target_section->output_offset
11298                            + stub_entry->target_section->output_section->vma);
11299
11300           rl = (htab->elf.irelplt->contents
11301                 + (htab->elf.irelplt->reloc_count++
11302                    * sizeof (Elf64_External_Rela)));
11303           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11304           stub_entry->plt_ent->plt.offset |= 1;
11305           htab->local_ifunc_resolver = 1;
11306         }
11307
11308       off = (dest
11309              - elf_gp (plt->output_section->owner)
11310              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11311
11312       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11313         {
11314           info->callbacks->einfo
11315             /* xgettext:c-format */
11316             (_("%P: linkage table error against `%T'\n"),
11317              stub_entry->h != NULL
11318              ? stub_entry->h->elf.root.root.string
11319              : "<local sym>");
11320           bfd_set_error (bfd_error_bad_value);
11321           htab->stub_error = TRUE;
11322           return FALSE;
11323         }
11324
11325       if (htab->params->plt_stub_align != 0)
11326         {
11327           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11328
11329           stub_entry->group->stub_sec->size += pad;
11330           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11331           loc += pad;
11332         }
11333
11334       r = NULL;
11335       if (info->emitrelocations)
11336         {
11337           r = get_relocs (stub_entry->group->stub_sec,
11338                           ((PPC_HA (off) != 0)
11339                            + (htab->opd_abi
11340                               ? 2 + (htab->params->plt_static_chain
11341                                      && PPC_HA (off + 16) == PPC_HA (off))
11342                               : 1)));
11343           if (r == NULL)
11344             return FALSE;
11345           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11346           if (bfd_big_endian (info->output_bfd))
11347             r[0].r_offset += 2;
11348           r[0].r_addend = dest;
11349         }
11350       if (stub_entry->h != NULL
11351           && (stub_entry->h == htab->tls_get_addr_fd
11352               || stub_entry->h == htab->tls_get_addr)
11353           && htab->params->tls_get_addr_opt)
11354         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11355       else
11356         p = build_plt_stub (htab, stub_entry, loc, off, r);
11357       size = p - loc;
11358       break;
11359
11360     case ppc_stub_save_res:
11361       return TRUE;
11362
11363     default:
11364       BFD_FAIL ();
11365       return FALSE;
11366     }
11367
11368   stub_entry->group->stub_sec->size += size;
11369
11370   if (htab->params->emit_stub_syms)
11371     {
11372       struct elf_link_hash_entry *h;
11373       size_t len1, len2;
11374       char *name;
11375       const char *const stub_str[] = { "long_branch",
11376                                        "long_branch_r2off",
11377                                        "plt_branch",
11378                                        "plt_branch_r2off",
11379                                        "plt_call",
11380                                        "plt_call" };
11381
11382       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11383       len2 = strlen (stub_entry->root.string);
11384       name = bfd_malloc (len1 + len2 + 2);
11385       if (name == NULL)
11386         return FALSE;
11387       memcpy (name, stub_entry->root.string, 9);
11388       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11389       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11390       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11391       if (h == NULL)
11392         return FALSE;
11393       if (h->root.type == bfd_link_hash_new)
11394         {
11395           h->root.type = bfd_link_hash_defined;
11396           h->root.u.def.section = stub_entry->group->stub_sec;
11397           h->root.u.def.value = stub_entry->stub_offset;
11398           h->ref_regular = 1;
11399           h->def_regular = 1;
11400           h->ref_regular_nonweak = 1;
11401           h->forced_local = 1;
11402           h->non_elf = 0;
11403           h->root.linker_def = 1;
11404         }
11405     }
11406
11407   return TRUE;
11408 }
11409
11410 /* As above, but don't actually build the stub.  Just bump offset so
11411    we know stub section sizes, and select plt_branch stubs where
11412    long_branch stubs won't do.  */
11413
11414 static bfd_boolean
11415 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11416 {
11417   struct ppc_stub_hash_entry *stub_entry;
11418   struct bfd_link_info *info;
11419   struct ppc_link_hash_table *htab;
11420   bfd_vma off;
11421   int size;
11422
11423   /* Massage our args to the form they really have.  */
11424   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11425   info = in_arg;
11426
11427   htab = ppc_hash_table (info);
11428   if (htab == NULL)
11429     return FALSE;
11430
11431   if (stub_entry->h != NULL
11432       && stub_entry->h->save_res
11433       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11434       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11435     {
11436       /* Don't make stubs to out-of-line register save/restore
11437          functions.  Instead, emit copies of the functions.  */
11438       stub_entry->group->needs_save_res = 1;
11439       stub_entry->stub_type = ppc_stub_save_res;
11440       return TRUE;
11441     }
11442
11443   if (stub_entry->stub_type == ppc_stub_plt_call
11444       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11445     {
11446       asection *plt;
11447       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11448       if (off >= (bfd_vma) -2)
11449         abort ();
11450       plt = htab->elf.splt;
11451       if (!htab->elf.dynamic_sections_created
11452           || stub_entry->h == NULL
11453           || stub_entry->h->elf.dynindx == -1)
11454         plt = htab->elf.iplt;
11455       off += (plt->output_offset
11456               + plt->output_section->vma
11457               - elf_gp (plt->output_section->owner)
11458               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11459
11460       size = plt_stub_size (htab, stub_entry, off);
11461       if (stub_entry->h != NULL
11462           && (stub_entry->h == htab->tls_get_addr_fd
11463               || stub_entry->h == htab->tls_get_addr)
11464           && htab->params->tls_get_addr_opt
11465           && (ALWAYS_EMIT_R2SAVE
11466               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11467         stub_entry->group->tls_get_addr_opt_bctrl
11468           = stub_entry->group->stub_sec->size + size - 5 * 4;
11469
11470       if (htab->params->plt_stub_align)
11471         size += plt_stub_pad (htab, stub_entry, off);
11472       if (info->emitrelocations)
11473         {
11474           stub_entry->group->stub_sec->reloc_count
11475             += ((PPC_HA (off) != 0)
11476                 + (htab->opd_abi
11477                    ? 2 + (htab->params->plt_static_chain
11478                           && PPC_HA (off + 16) == PPC_HA (off))
11479                    : 1));
11480           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11481         }
11482     }
11483   else
11484     {
11485       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11486          variants.  */
11487       bfd_vma r2off = 0;
11488       bfd_vma local_off = 0;
11489
11490       off = (stub_entry->target_value
11491              + stub_entry->target_section->output_offset
11492              + stub_entry->target_section->output_section->vma);
11493       off -= (stub_entry->group->stub_sec->size
11494               + stub_entry->group->stub_sec->output_offset
11495               + stub_entry->group->stub_sec->output_section->vma);
11496
11497       /* Reset the stub type from the plt variant in case we now
11498          can reach with a shorter stub.  */
11499       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11500         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11501
11502       size = 4;
11503       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11504         {
11505           r2off = get_r2off (info, stub_entry);
11506           if (r2off == (bfd_vma) -1)
11507             {
11508               htab->stub_error = TRUE;
11509               return FALSE;
11510             }
11511           size = 8;
11512           if (PPC_HA (r2off) != 0)
11513             size += 4;
11514           if (PPC_LO (r2off) != 0)
11515             size += 4;
11516           off -= size - 4;
11517         }
11518
11519       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11520
11521       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11522          Do the same for -R objects without function descriptors.  */
11523       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11524           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11525               && r2off == 0
11526               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11527         {
11528           struct ppc_branch_hash_entry *br_entry;
11529
11530           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11531                                              stub_entry->root.string + 9,
11532                                              TRUE, FALSE);
11533           if (br_entry == NULL)
11534             {
11535               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11536                                       stub_entry->root.string);
11537               htab->stub_error = TRUE;
11538               return FALSE;
11539             }
11540
11541           if (br_entry->iter != htab->stub_iteration)
11542             {
11543               br_entry->iter = htab->stub_iteration;
11544               br_entry->offset = htab->brlt->size;
11545               htab->brlt->size += 8;
11546
11547               if (htab->relbrlt != NULL)
11548                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11549               else if (info->emitrelocations)
11550                 {
11551                   htab->brlt->reloc_count += 1;
11552                   htab->brlt->flags |= SEC_RELOC;
11553                 }
11554             }
11555
11556           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11557           off = (br_entry->offset
11558                  + htab->brlt->output_offset
11559                  + htab->brlt->output_section->vma
11560                  - elf_gp (htab->brlt->output_section->owner)
11561                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11562
11563           if (info->emitrelocations)
11564             {
11565               stub_entry->group->stub_sec->reloc_count
11566                 += 1 + (PPC_HA (off) != 0);
11567               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11568             }
11569
11570           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11571             {
11572               size = 12;
11573               if (PPC_HA (off) != 0)
11574                 size = 16;
11575             }
11576           else
11577             {
11578               size = 16;
11579               if (PPC_HA (off) != 0)
11580                 size += 4;
11581
11582               if (PPC_HA (r2off) != 0)
11583                 size += 4;
11584               if (PPC_LO (r2off) != 0)
11585                 size += 4;
11586             }
11587         }
11588       else if (info->emitrelocations)
11589         {
11590           stub_entry->group->stub_sec->reloc_count += 1;
11591           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11592         }
11593     }
11594
11595   stub_entry->group->stub_sec->size += size;
11596   return TRUE;
11597 }
11598
11599 /* Set up various things so that we can make a list of input sections
11600    for each output section included in the link.  Returns -1 on error,
11601    0 when no stubs will be needed, and 1 on success.  */
11602
11603 int
11604 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11605 {
11606   unsigned int id;
11607   bfd_size_type amt;
11608   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11609
11610   if (htab == NULL)
11611     return -1;
11612
11613   htab->sec_info_arr_size = bfd_get_next_section_id ();
11614   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11615   htab->sec_info = bfd_zmalloc (amt);
11616   if (htab->sec_info == NULL)
11617     return -1;
11618
11619   /* Set toc_off for com, und, abs and ind sections.  */
11620   for (id = 0; id < 3; id++)
11621     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11622
11623   return 1;
11624 }
11625
11626 /* Set up for first pass at multitoc partitioning.  */
11627
11628 void
11629 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11630 {
11631   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11632
11633   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11634   htab->toc_bfd = NULL;
11635   htab->toc_first_sec = NULL;
11636 }
11637
11638 /* The linker repeatedly calls this function for each TOC input section
11639    and linker generated GOT section.  Group input bfds such that the toc
11640    within a group is less than 64k in size.  */
11641
11642 bfd_boolean
11643 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11644 {
11645   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11646   bfd_vma addr, off, limit;
11647
11648   if (htab == NULL)
11649     return FALSE;
11650
11651   if (!htab->second_toc_pass)
11652     {
11653       /* Keep track of the first .toc or .got section for this input bfd.  */
11654       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11655
11656       if (new_bfd)
11657         {
11658           htab->toc_bfd = isec->owner;
11659           htab->toc_first_sec = isec;
11660         }
11661
11662       addr = isec->output_offset + isec->output_section->vma;
11663       off = addr - htab->toc_curr;
11664       limit = 0x80008000;
11665       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11666         limit = 0x10000;
11667       if (off + isec->size > limit)
11668         {
11669           addr = (htab->toc_first_sec->output_offset
11670                   + htab->toc_first_sec->output_section->vma);
11671           htab->toc_curr = addr;
11672           htab->toc_curr &= -TOC_BASE_ALIGN;
11673         }
11674
11675       /* toc_curr is the base address of this toc group.  Set elf_gp
11676          for the input section to be the offset relative to the
11677          output toc base plus 0x8000.  Making the input elf_gp an
11678          offset allows us to move the toc as a whole without
11679          recalculating input elf_gp.  */
11680       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11681       off += TOC_BASE_OFF;
11682
11683       /* Die if someone uses a linker script that doesn't keep input
11684          file .toc and .got together.  */
11685       if (new_bfd
11686           && elf_gp (isec->owner) != 0
11687           && elf_gp (isec->owner) != off)
11688         return FALSE;
11689
11690       elf_gp (isec->owner) = off;
11691       return TRUE;
11692     }
11693
11694   /* During the second pass toc_first_sec points to the start of
11695      a toc group, and toc_curr is used to track the old elf_gp.
11696      We use toc_bfd to ensure we only look at each bfd once.  */
11697   if (htab->toc_bfd == isec->owner)
11698     return TRUE;
11699   htab->toc_bfd = isec->owner;
11700
11701   if (htab->toc_first_sec == NULL
11702       || htab->toc_curr != elf_gp (isec->owner))
11703     {
11704       htab->toc_curr = elf_gp (isec->owner);
11705       htab->toc_first_sec = isec;
11706     }
11707   addr = (htab->toc_first_sec->output_offset
11708           + htab->toc_first_sec->output_section->vma);
11709   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11710   elf_gp (isec->owner) = off;
11711
11712   return TRUE;
11713 }
11714
11715 /* Called via elf_link_hash_traverse to merge GOT entries for global
11716    symbol H.  */
11717
11718 static bfd_boolean
11719 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11720 {
11721   if (h->root.type == bfd_link_hash_indirect)
11722     return TRUE;
11723
11724   merge_got_entries (&h->got.glist);
11725
11726   return TRUE;
11727 }
11728
11729 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11730    symbol H.  */
11731
11732 static bfd_boolean
11733 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11734 {
11735   struct got_entry *gent;
11736
11737   if (h->root.type == bfd_link_hash_indirect)
11738     return TRUE;
11739
11740   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11741     if (!gent->is_indirect)
11742       allocate_got (h, (struct bfd_link_info *) inf, gent);
11743   return TRUE;
11744 }
11745
11746 /* Called on the first multitoc pass after the last call to
11747    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11748    entries.  */
11749
11750 bfd_boolean
11751 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11752 {
11753   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11754   struct bfd *ibfd, *ibfd2;
11755   bfd_boolean done_something;
11756
11757   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11758
11759   if (!htab->do_multi_toc)
11760     return FALSE;
11761
11762   /* Merge global sym got entries within a toc group.  */
11763   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11764
11765   /* And tlsld_got.  */
11766   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11767     {
11768       struct got_entry *ent, *ent2;
11769
11770       if (!is_ppc64_elf (ibfd))
11771         continue;
11772
11773       ent = ppc64_tlsld_got (ibfd);
11774       if (!ent->is_indirect
11775           && ent->got.offset != (bfd_vma) -1)
11776         {
11777           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11778             {
11779               if (!is_ppc64_elf (ibfd2))
11780                 continue;
11781
11782               ent2 = ppc64_tlsld_got (ibfd2);
11783               if (!ent2->is_indirect
11784                   && ent2->got.offset != (bfd_vma) -1
11785                   && elf_gp (ibfd2) == elf_gp (ibfd))
11786                 {
11787                   ent2->is_indirect = TRUE;
11788                   ent2->got.ent = ent;
11789                 }
11790             }
11791         }
11792     }
11793
11794   /* Zap sizes of got sections.  */
11795   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11796   htab->elf.irelplt->size -= htab->got_reli_size;
11797   htab->got_reli_size = 0;
11798
11799   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11800     {
11801       asection *got, *relgot;
11802
11803       if (!is_ppc64_elf (ibfd))
11804         continue;
11805
11806       got = ppc64_elf_tdata (ibfd)->got;
11807       if (got != NULL)
11808         {
11809           got->rawsize = got->size;
11810           got->size = 0;
11811           relgot = ppc64_elf_tdata (ibfd)->relgot;
11812           relgot->rawsize = relgot->size;
11813           relgot->size = 0;
11814         }
11815     }
11816
11817   /* Now reallocate the got, local syms first.  We don't need to
11818      allocate section contents again since we never increase size.  */
11819   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11820     {
11821       struct got_entry **lgot_ents;
11822       struct got_entry **end_lgot_ents;
11823       struct plt_entry **local_plt;
11824       struct plt_entry **end_local_plt;
11825       unsigned char *lgot_masks;
11826       bfd_size_type locsymcount;
11827       Elf_Internal_Shdr *symtab_hdr;
11828       asection *s;
11829
11830       if (!is_ppc64_elf (ibfd))
11831         continue;
11832
11833       lgot_ents = elf_local_got_ents (ibfd);
11834       if (!lgot_ents)
11835         continue;
11836
11837       symtab_hdr = &elf_symtab_hdr (ibfd);
11838       locsymcount = symtab_hdr->sh_info;
11839       end_lgot_ents = lgot_ents + locsymcount;
11840       local_plt = (struct plt_entry **) end_lgot_ents;
11841       end_local_plt = local_plt + locsymcount;
11842       lgot_masks = (unsigned char *) end_local_plt;
11843       s = ppc64_elf_tdata (ibfd)->got;
11844       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11845         {
11846           struct got_entry *ent;
11847
11848           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11849             {
11850               unsigned int ent_size = 8;
11851               unsigned int rel_size = sizeof (Elf64_External_Rela);
11852
11853               ent->got.offset = s->size;
11854               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11855                 {
11856                   ent_size *= 2;
11857                   rel_size *= 2;
11858                 }
11859               s->size += ent_size;
11860               if ((*lgot_masks & PLT_IFUNC) != 0)
11861                 {
11862                   htab->elf.irelplt->size += rel_size;
11863                   htab->got_reli_size += rel_size;
11864                 }
11865               else if (bfd_link_pic (info))
11866                 {
11867                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11868                   srel->size += rel_size;
11869                 }
11870             }
11871         }
11872     }
11873
11874   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11875
11876   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11877     {
11878       struct got_entry *ent;
11879
11880       if (!is_ppc64_elf (ibfd))
11881         continue;
11882
11883       ent = ppc64_tlsld_got (ibfd);
11884       if (!ent->is_indirect
11885           && ent->got.offset != (bfd_vma) -1)
11886         {
11887           asection *s = ppc64_elf_tdata (ibfd)->got;
11888           ent->got.offset = s->size;
11889           s->size += 16;
11890           if (bfd_link_pic (info))
11891             {
11892               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11893               srel->size += sizeof (Elf64_External_Rela);
11894             }
11895         }
11896     }
11897
11898   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11899   if (!done_something)
11900     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11901       {
11902         asection *got;
11903
11904         if (!is_ppc64_elf (ibfd))
11905           continue;
11906
11907         got = ppc64_elf_tdata (ibfd)->got;
11908         if (got != NULL)
11909           {
11910             done_something = got->rawsize != got->size;
11911             if (done_something)
11912               break;
11913           }
11914       }
11915
11916   if (done_something)
11917     (*htab->params->layout_sections_again) ();
11918
11919   /* Set up for second pass over toc sections to recalculate elf_gp
11920      on input sections.  */
11921   htab->toc_bfd = NULL;
11922   htab->toc_first_sec = NULL;
11923   htab->second_toc_pass = TRUE;
11924   return done_something;
11925 }
11926
11927 /* Called after second pass of multitoc partitioning.  */
11928
11929 void
11930 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11931 {
11932   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11933
11934   /* After the second pass, toc_curr tracks the TOC offset used
11935      for code sections below in ppc64_elf_next_input_section.  */
11936   htab->toc_curr = TOC_BASE_OFF;
11937 }
11938
11939 /* No toc references were found in ISEC.  If the code in ISEC makes no
11940    calls, then there's no need to use toc adjusting stubs when branching
11941    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11942    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11943    needed, and 2 if a cyclical call-graph was found but no other reason
11944    for a stub was detected.  If called from the top level, a return of
11945    2 means the same as a return of 0.  */
11946
11947 static int
11948 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11949 {
11950   int ret;
11951
11952   /* Mark this section as checked.  */
11953   isec->call_check_done = 1;
11954
11955   /* We know none of our code bearing sections will need toc stubs.  */
11956   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11957     return 0;
11958
11959   if (isec->size == 0)
11960     return 0;
11961
11962   if (isec->output_section == NULL)
11963     return 0;
11964
11965   ret = 0;
11966   if (isec->reloc_count != 0)
11967     {
11968       Elf_Internal_Rela *relstart, *rel;
11969       Elf_Internal_Sym *local_syms;
11970       struct ppc_link_hash_table *htab;
11971
11972       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11973                                             info->keep_memory);
11974       if (relstart == NULL)
11975         return -1;
11976
11977       /* Look for branches to outside of this section.  */
11978       local_syms = NULL;
11979       htab = ppc_hash_table (info);
11980       if (htab == NULL)
11981         return -1;
11982
11983       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11984         {
11985           enum elf_ppc64_reloc_type r_type;
11986           unsigned long r_symndx;
11987           struct elf_link_hash_entry *h;
11988           struct ppc_link_hash_entry *eh;
11989           Elf_Internal_Sym *sym;
11990           asection *sym_sec;
11991           struct _opd_sec_data *opd;
11992           bfd_vma sym_value;
11993           bfd_vma dest;
11994
11995           r_type = ELF64_R_TYPE (rel->r_info);
11996           if (r_type != R_PPC64_REL24
11997               && r_type != R_PPC64_REL14
11998               && r_type != R_PPC64_REL14_BRTAKEN
11999               && r_type != R_PPC64_REL14_BRNTAKEN)
12000             continue;
12001
12002           r_symndx = ELF64_R_SYM (rel->r_info);
12003           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12004                           isec->owner))
12005             {
12006               ret = -1;
12007               break;
12008             }
12009
12010           /* Calls to dynamic lib functions go through a plt call stub
12011              that uses r2.  */
12012           eh = (struct ppc_link_hash_entry *) h;
12013           if (eh != NULL
12014               && (eh->elf.plt.plist != NULL
12015                   || (eh->oh != NULL
12016                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12017             {
12018               ret = 1;
12019               break;
12020             }
12021
12022           if (sym_sec == NULL)
12023             /* Ignore other undefined symbols.  */
12024             continue;
12025
12026           /* Assume branches to other sections not included in the
12027              link need stubs too, to cover -R and absolute syms.  */
12028           if (sym_sec->output_section == NULL)
12029             {
12030               ret = 1;
12031               break;
12032             }
12033
12034           if (h == NULL)
12035             sym_value = sym->st_value;
12036           else
12037             {
12038               if (h->root.type != bfd_link_hash_defined
12039                   && h->root.type != bfd_link_hash_defweak)
12040                 abort ();
12041               sym_value = h->root.u.def.value;
12042             }
12043           sym_value += rel->r_addend;
12044
12045           /* If this branch reloc uses an opd sym, find the code section.  */
12046           opd = get_opd_info (sym_sec);
12047           if (opd != NULL)
12048             {
12049               if (h == NULL && opd->adjust != NULL)
12050                 {
12051                   long adjust;
12052
12053                   adjust = opd->adjust[OPD_NDX (sym_value)];
12054                   if (adjust == -1)
12055                     /* Assume deleted functions won't ever be called.  */
12056                     continue;
12057                   sym_value += adjust;
12058                 }
12059
12060               dest = opd_entry_value (sym_sec, sym_value,
12061                                       &sym_sec, NULL, FALSE);
12062               if (dest == (bfd_vma) -1)
12063                 continue;
12064             }
12065           else
12066             dest = (sym_value
12067                     + sym_sec->output_offset
12068                     + sym_sec->output_section->vma);
12069
12070           /* Ignore branch to self.  */
12071           if (sym_sec == isec)
12072             continue;
12073
12074           /* If the called function uses the toc, we need a stub.  */
12075           if (sym_sec->has_toc_reloc
12076               || sym_sec->makes_toc_func_call)
12077             {
12078               ret = 1;
12079               break;
12080             }
12081
12082           /* Assume any branch that needs a long branch stub might in fact
12083              need a plt_branch stub.  A plt_branch stub uses r2.  */
12084           else if (dest - (isec->output_offset
12085                            + isec->output_section->vma
12086                            + rel->r_offset) + (1 << 25)
12087                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12088                                                              ? h->other
12089                                                              : sym->st_other))
12090             {
12091               ret = 1;
12092               break;
12093             }
12094
12095           /* If calling back to a section in the process of being
12096              tested, we can't say for sure that no toc adjusting stubs
12097              are needed, so don't return zero.  */
12098           else if (sym_sec->call_check_in_progress)
12099             ret = 2;
12100
12101           /* Branches to another section that itself doesn't have any TOC
12102              references are OK.  Recursively call ourselves to check.  */
12103           else if (!sym_sec->call_check_done)
12104             {
12105               int recur;
12106
12107               /* Mark current section as indeterminate, so that other
12108                  sections that call back to current won't be marked as
12109                  known.  */
12110               isec->call_check_in_progress = 1;
12111               recur = toc_adjusting_stub_needed (info, sym_sec);
12112               isec->call_check_in_progress = 0;
12113
12114               if (recur != 0)
12115                 {
12116                   ret = recur;
12117                   if (recur != 2)
12118                     break;
12119                 }
12120             }
12121         }
12122
12123       if (local_syms != NULL
12124           && (elf_symtab_hdr (isec->owner).contents
12125               != (unsigned char *) local_syms))
12126         free (local_syms);
12127       if (elf_section_data (isec)->relocs != relstart)
12128         free (relstart);
12129     }
12130
12131   if ((ret & 1) == 0
12132       && isec->map_head.s != NULL
12133       && (strcmp (isec->output_section->name, ".init") == 0
12134           || strcmp (isec->output_section->name, ".fini") == 0))
12135     {
12136       if (isec->map_head.s->has_toc_reloc
12137           || isec->map_head.s->makes_toc_func_call)
12138         ret = 1;
12139       else if (!isec->map_head.s->call_check_done)
12140         {
12141           int recur;
12142           isec->call_check_in_progress = 1;
12143           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12144           isec->call_check_in_progress = 0;
12145           if (recur != 0)
12146             ret = recur;
12147         }
12148     }
12149
12150   if (ret == 1)
12151     isec->makes_toc_func_call = 1;
12152
12153   return ret;
12154 }
12155
12156 /* The linker repeatedly calls this function for each input section,
12157    in the order that input sections are linked into output sections.
12158    Build lists of input sections to determine groupings between which
12159    we may insert linker stubs.  */
12160
12161 bfd_boolean
12162 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12163 {
12164   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12165
12166   if (htab == NULL)
12167     return FALSE;
12168
12169   if ((isec->output_section->flags & SEC_CODE) != 0
12170       && isec->output_section->id < htab->sec_info_arr_size)
12171     {
12172       /* This happens to make the list in reverse order,
12173          which is what we want.  */
12174       htab->sec_info[isec->id].u.list
12175         = htab->sec_info[isec->output_section->id].u.list;
12176       htab->sec_info[isec->output_section->id].u.list = isec;
12177     }
12178
12179   if (htab->multi_toc_needed)
12180     {
12181       /* Analyse sections that aren't already flagged as needing a
12182          valid toc pointer.  Exclude .fixup for the linux kernel.
12183          .fixup contains branches, but only back to the function that
12184          hit an exception.  */
12185       if (!(isec->has_toc_reloc
12186             || (isec->flags & SEC_CODE) == 0
12187             || strcmp (isec->name, ".fixup") == 0
12188             || isec->call_check_done))
12189         {
12190           if (toc_adjusting_stub_needed (info, isec) < 0)
12191             return FALSE;
12192         }
12193       /* Make all sections use the TOC assigned for this object file.
12194          This will be wrong for pasted sections;  We fix that in
12195          check_pasted_section().  */
12196       if (elf_gp (isec->owner) != 0)
12197         htab->toc_curr = elf_gp (isec->owner);
12198     }
12199
12200   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12201   return TRUE;
12202 }
12203
12204 /* Check that all .init and .fini sections use the same toc, if they
12205    have toc relocs.  */
12206
12207 static bfd_boolean
12208 check_pasted_section (struct bfd_link_info *info, const char *name)
12209 {
12210   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12211
12212   if (o != NULL)
12213     {
12214       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12215       bfd_vma toc_off = 0;
12216       asection *i;
12217
12218       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12219         if (i->has_toc_reloc)
12220           {
12221             if (toc_off == 0)
12222               toc_off = htab->sec_info[i->id].toc_off;
12223             else if (toc_off != htab->sec_info[i->id].toc_off)
12224               return FALSE;
12225           }
12226
12227       if (toc_off == 0)
12228         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12229           if (i->makes_toc_func_call)
12230             {
12231               toc_off = htab->sec_info[i->id].toc_off;
12232               break;
12233             }
12234
12235       /* Make sure the whole pasted function uses the same toc offset.  */
12236       if (toc_off != 0)
12237         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12238           htab->sec_info[i->id].toc_off = toc_off;
12239     }
12240   return TRUE;
12241 }
12242
12243 bfd_boolean
12244 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12245 {
12246   return (check_pasted_section (info, ".init")
12247           & check_pasted_section (info, ".fini"));
12248 }
12249
12250 /* See whether we can group stub sections together.  Grouping stub
12251    sections may result in fewer stubs.  More importantly, we need to
12252    put all .init* and .fini* stubs at the beginning of the .init or
12253    .fini output sections respectively, because glibc splits the
12254    _init and _fini functions into multiple parts.  Putting a stub in
12255    the middle of a function is not a good idea.  */
12256
12257 static bfd_boolean
12258 group_sections (struct bfd_link_info *info,
12259                 bfd_size_type stub_group_size,
12260                 bfd_boolean stubs_always_before_branch)
12261 {
12262   struct ppc_link_hash_table *htab;
12263   asection *osec;
12264   bfd_boolean suppress_size_errors;
12265
12266   htab = ppc_hash_table (info);
12267   if (htab == NULL)
12268     return FALSE;
12269
12270   suppress_size_errors = FALSE;
12271   if (stub_group_size == 1)
12272     {
12273       /* Default values.  */
12274       if (stubs_always_before_branch)
12275         stub_group_size = 0x1e00000;
12276       else
12277         stub_group_size = 0x1c00000;
12278       suppress_size_errors = TRUE;
12279     }
12280
12281   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12282     {
12283       asection *tail;
12284
12285       if (osec->id >= htab->sec_info_arr_size)
12286         continue;
12287
12288       tail = htab->sec_info[osec->id].u.list;
12289       while (tail != NULL)
12290         {
12291           asection *curr;
12292           asection *prev;
12293           bfd_size_type total;
12294           bfd_boolean big_sec;
12295           bfd_vma curr_toc;
12296           struct map_stub *group;
12297           bfd_size_type group_size;
12298
12299           curr = tail;
12300           total = tail->size;
12301           group_size = (ppc64_elf_section_data (tail) != NULL
12302                         && ppc64_elf_section_data (tail)->has_14bit_branch
12303                         ? stub_group_size >> 10 : stub_group_size);
12304
12305           big_sec = total > group_size;
12306           if (big_sec && !suppress_size_errors)
12307             /* xgettext:c-format */
12308             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12309                                 tail->owner, tail);
12310           curr_toc = htab->sec_info[tail->id].toc_off;
12311
12312           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12313                  && ((total += curr->output_offset - prev->output_offset)
12314                      < (ppc64_elf_section_data (prev) != NULL
12315                         && ppc64_elf_section_data (prev)->has_14bit_branch
12316                         ? (group_size = stub_group_size >> 10) : group_size))
12317                  && htab->sec_info[prev->id].toc_off == curr_toc)
12318             curr = prev;
12319
12320           /* OK, the size from the start of CURR to the end is less
12321              than group_size and thus can be handled by one stub
12322              section.  (or the tail section is itself larger than
12323              group_size, in which case we may be toast.)  We should
12324              really be keeping track of the total size of stubs added
12325              here, as stubs contribute to the final output section
12326              size.  That's a little tricky, and this way will only
12327              break if stubs added make the total size more than 2^25,
12328              ie. for the default stub_group_size, if stubs total more
12329              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12330           group = bfd_alloc (curr->owner, sizeof (*group));
12331           if (group == NULL)
12332             return FALSE;
12333           group->link_sec = curr;
12334           group->stub_sec = NULL;
12335           group->needs_save_res = 0;
12336           group->tls_get_addr_opt_bctrl = -1u;
12337           group->next = htab->group;
12338           htab->group = group;
12339           do
12340             {
12341               prev = htab->sec_info[tail->id].u.list;
12342               /* Set up this stub group.  */
12343               htab->sec_info[tail->id].u.group = group;
12344             }
12345           while (tail != curr && (tail = prev) != NULL);
12346
12347           /* But wait, there's more!  Input sections up to group_size
12348              bytes before the stub section can be handled by it too.
12349              Don't do this if we have a really large section after the
12350              stubs, as adding more stubs increases the chance that
12351              branches may not reach into the stub section.  */
12352           if (!stubs_always_before_branch && !big_sec)
12353             {
12354               total = 0;
12355               while (prev != NULL
12356                      && ((total += tail->output_offset - prev->output_offset)
12357                          < (ppc64_elf_section_data (prev) != NULL
12358                             && ppc64_elf_section_data (prev)->has_14bit_branch
12359                             ? (group_size = stub_group_size >> 10) : group_size))
12360                      && htab->sec_info[prev->id].toc_off == curr_toc)
12361                 {
12362                   tail = prev;
12363                   prev = htab->sec_info[tail->id].u.list;
12364                   htab->sec_info[tail->id].u.group = group;
12365                 }
12366             }
12367           tail = prev;
12368         }
12369     }
12370   return TRUE;
12371 }
12372
12373 static const unsigned char glink_eh_frame_cie[] =
12374 {
12375   0, 0, 0, 16,                          /* length.  */
12376   0, 0, 0, 0,                           /* id.  */
12377   1,                                    /* CIE version.  */
12378   'z', 'R', 0,                          /* Augmentation string.  */
12379   4,                                    /* Code alignment.  */
12380   0x78,                                 /* Data alignment.  */
12381   65,                                   /* RA reg.  */
12382   1,                                    /* Augmentation size.  */
12383   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12384   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12385 };
12386
12387 static size_t
12388 stub_eh_frame_size (struct map_stub *group, size_t align)
12389 {
12390   size_t this_size = 17;
12391   if (group->tls_get_addr_opt_bctrl != -1u)
12392     {
12393       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12394       if (to_bctrl < 64)
12395         this_size += 1;
12396       else if (to_bctrl < 256)
12397         this_size += 2;
12398       else if (to_bctrl < 65536)
12399         this_size += 3;
12400       else
12401         this_size += 5;
12402       this_size += 6;
12403     }
12404   this_size = (this_size + align - 1) & -align;
12405   return this_size;
12406 }
12407
12408 /* Stripping output sections is normally done before dynamic section
12409    symbols have been allocated.  This function is called later, and
12410    handles cases like htab->brlt which is mapped to its own output
12411    section.  */
12412
12413 static void
12414 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12415 {
12416   if (isec->size == 0
12417       && isec->output_section->size == 0
12418       && !(isec->output_section->flags & SEC_KEEP)
12419       && !bfd_section_removed_from_list (info->output_bfd,
12420                                          isec->output_section)
12421       && elf_section_data (isec->output_section)->dynindx == 0)
12422     {
12423       isec->output_section->flags |= SEC_EXCLUDE;
12424       bfd_section_list_remove (info->output_bfd, isec->output_section);
12425       info->output_bfd->section_count--;
12426     }
12427 }
12428
12429 /* Determine and set the size of the stub section for a final link.
12430
12431    The basic idea here is to examine all the relocations looking for
12432    PC-relative calls to a target that is unreachable with a "bl"
12433    instruction.  */
12434
12435 bfd_boolean
12436 ppc64_elf_size_stubs (struct bfd_link_info *info)
12437 {
12438   bfd_size_type stub_group_size;
12439   bfd_boolean stubs_always_before_branch;
12440   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12441
12442   if (htab == NULL)
12443     return FALSE;
12444
12445   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12446     htab->params->plt_thread_safe = 1;
12447   if (!htab->opd_abi)
12448     htab->params->plt_thread_safe = 0;
12449   else if (htab->params->plt_thread_safe == -1)
12450     {
12451       static const char *const thread_starter[] =
12452         {
12453           "pthread_create",
12454           /* libstdc++ */
12455           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12456           /* librt */
12457           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12458           "mq_notify", "create_timer",
12459           /* libanl */
12460           "getaddrinfo_a",
12461           /* libgomp */
12462           "GOMP_parallel",
12463           "GOMP_parallel_start",
12464           "GOMP_parallel_loop_static",
12465           "GOMP_parallel_loop_static_start",
12466           "GOMP_parallel_loop_dynamic",
12467           "GOMP_parallel_loop_dynamic_start",
12468           "GOMP_parallel_loop_guided",
12469           "GOMP_parallel_loop_guided_start",
12470           "GOMP_parallel_loop_runtime",
12471           "GOMP_parallel_loop_runtime_start",
12472           "GOMP_parallel_sections",
12473           "GOMP_parallel_sections_start",
12474           /* libgo */
12475           "__go_go",
12476         };
12477       unsigned i;
12478
12479       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12480         {
12481           struct elf_link_hash_entry *h;
12482           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12483                                     FALSE, FALSE, TRUE);
12484           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12485           if (htab->params->plt_thread_safe)
12486             break;
12487         }
12488     }
12489   stubs_always_before_branch = htab->params->group_size < 0;
12490   if (htab->params->group_size < 0)
12491     stub_group_size = -htab->params->group_size;
12492   else
12493     stub_group_size = htab->params->group_size;
12494
12495   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12496     return FALSE;
12497
12498 #define STUB_SHRINK_ITER 20
12499   /* Loop until no stubs added.  After iteration 20 of this loop we may
12500      exit on a stub section shrinking.  This is to break out of a
12501      pathological case where adding stubs on one iteration decreases
12502      section gaps (perhaps due to alignment), which then requires
12503      fewer or smaller stubs on the next iteration.  */
12504
12505   while (1)
12506     {
12507       bfd *input_bfd;
12508       unsigned int bfd_indx;
12509       struct map_stub *group;
12510
12511       htab->stub_iteration += 1;
12512
12513       for (input_bfd = info->input_bfds, bfd_indx = 0;
12514            input_bfd != NULL;
12515            input_bfd = input_bfd->link.next, bfd_indx++)
12516         {
12517           Elf_Internal_Shdr *symtab_hdr;
12518           asection *section;
12519           Elf_Internal_Sym *local_syms = NULL;
12520
12521           if (!is_ppc64_elf (input_bfd))
12522             continue;
12523
12524           /* We'll need the symbol table in a second.  */
12525           symtab_hdr = &elf_symtab_hdr (input_bfd);
12526           if (symtab_hdr->sh_info == 0)
12527             continue;
12528
12529           /* Walk over each section attached to the input bfd.  */
12530           for (section = input_bfd->sections;
12531                section != NULL;
12532                section = section->next)
12533             {
12534               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12535
12536               /* If there aren't any relocs, then there's nothing more
12537                  to do.  */
12538               if ((section->flags & SEC_RELOC) == 0
12539                   || (section->flags & SEC_ALLOC) == 0
12540                   || (section->flags & SEC_LOAD) == 0
12541                   || (section->flags & SEC_CODE) == 0
12542                   || section->reloc_count == 0)
12543                 continue;
12544
12545               /* If this section is a link-once section that will be
12546                  discarded, then don't create any stubs.  */
12547               if (section->output_section == NULL
12548                   || section->output_section->owner != info->output_bfd)
12549                 continue;
12550
12551               /* Get the relocs.  */
12552               internal_relocs
12553                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12554                                              info->keep_memory);
12555               if (internal_relocs == NULL)
12556                 goto error_ret_free_local;
12557
12558               /* Now examine each relocation.  */
12559               irela = internal_relocs;
12560               irelaend = irela + section->reloc_count;
12561               for (; irela < irelaend; irela++)
12562                 {
12563                   enum elf_ppc64_reloc_type r_type;
12564                   unsigned int r_indx;
12565                   enum ppc_stub_type stub_type;
12566                   struct ppc_stub_hash_entry *stub_entry;
12567                   asection *sym_sec, *code_sec;
12568                   bfd_vma sym_value, code_value;
12569                   bfd_vma destination;
12570                   unsigned long local_off;
12571                   bfd_boolean ok_dest;
12572                   struct ppc_link_hash_entry *hash;
12573                   struct ppc_link_hash_entry *fdh;
12574                   struct elf_link_hash_entry *h;
12575                   Elf_Internal_Sym *sym;
12576                   char *stub_name;
12577                   const asection *id_sec;
12578                   struct _opd_sec_data *opd;
12579                   struct plt_entry *plt_ent;
12580
12581                   r_type = ELF64_R_TYPE (irela->r_info);
12582                   r_indx = ELF64_R_SYM (irela->r_info);
12583
12584                   if (r_type >= R_PPC64_max)
12585                     {
12586                       bfd_set_error (bfd_error_bad_value);
12587                       goto error_ret_free_internal;
12588                     }
12589
12590                   /* Only look for stubs on branch instructions.  */
12591                   if (r_type != R_PPC64_REL24
12592                       && r_type != R_PPC64_REL14
12593                       && r_type != R_PPC64_REL14_BRTAKEN
12594                       && r_type != R_PPC64_REL14_BRNTAKEN)
12595                     continue;
12596
12597                   /* Now determine the call target, its name, value,
12598                      section.  */
12599                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12600                                   r_indx, input_bfd))
12601                     goto error_ret_free_internal;
12602                   hash = (struct ppc_link_hash_entry *) h;
12603
12604                   ok_dest = FALSE;
12605                   fdh = NULL;
12606                   sym_value = 0;
12607                   if (hash == NULL)
12608                     {
12609                       sym_value = sym->st_value;
12610                       if (sym_sec != NULL
12611                           && sym_sec->output_section != NULL)
12612                         ok_dest = TRUE;
12613                     }
12614                   else if (hash->elf.root.type == bfd_link_hash_defined
12615                            || hash->elf.root.type == bfd_link_hash_defweak)
12616                     {
12617                       sym_value = hash->elf.root.u.def.value;
12618                       if (sym_sec->output_section != NULL)
12619                         ok_dest = TRUE;
12620                     }
12621                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12622                            || hash->elf.root.type == bfd_link_hash_undefined)
12623                     {
12624                       /* Recognise an old ABI func code entry sym, and
12625                          use the func descriptor sym instead if it is
12626                          defined.  */
12627                       if (hash->elf.root.root.string[0] == '.'
12628                           && hash->oh != NULL)
12629                         {
12630                           fdh = ppc_follow_link (hash->oh);
12631                           if (fdh->elf.root.type == bfd_link_hash_defined
12632                               || fdh->elf.root.type == bfd_link_hash_defweak)
12633                             {
12634                               sym_sec = fdh->elf.root.u.def.section;
12635                               sym_value = fdh->elf.root.u.def.value;
12636                               if (sym_sec->output_section != NULL)
12637                                 ok_dest = TRUE;
12638                             }
12639                           else
12640                             fdh = NULL;
12641                         }
12642                     }
12643                   else
12644                     {
12645                       bfd_set_error (bfd_error_bad_value);
12646                       goto error_ret_free_internal;
12647                     }
12648
12649                   destination = 0;
12650                   local_off = 0;
12651                   if (ok_dest)
12652                     {
12653                       sym_value += irela->r_addend;
12654                       destination = (sym_value
12655                                      + sym_sec->output_offset
12656                                      + sym_sec->output_section->vma);
12657                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12658                                                             ? hash->elf.other
12659                                                             : sym->st_other);
12660                     }
12661
12662                   code_sec = sym_sec;
12663                   code_value = sym_value;
12664                   opd = get_opd_info (sym_sec);
12665                   if (opd != NULL)
12666                     {
12667                       bfd_vma dest;
12668
12669                       if (hash == NULL && opd->adjust != NULL)
12670                         {
12671                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12672                           if (adjust == -1)
12673                             continue;
12674                           code_value += adjust;
12675                           sym_value += adjust;
12676                         }
12677                       dest = opd_entry_value (sym_sec, sym_value,
12678                                               &code_sec, &code_value, FALSE);
12679                       if (dest != (bfd_vma) -1)
12680                         {
12681                           destination = dest;
12682                           if (fdh != NULL)
12683                             {
12684                               /* Fixup old ABI sym to point at code
12685                                  entry.  */
12686                               hash->elf.root.type = bfd_link_hash_defweak;
12687                               hash->elf.root.u.def.section = code_sec;
12688                               hash->elf.root.u.def.value = code_value;
12689                             }
12690                         }
12691                     }
12692
12693                   /* Determine what (if any) linker stub is needed.  */
12694                   plt_ent = NULL;
12695                   stub_type = ppc_type_of_stub (section, irela, &hash,
12696                                                 &plt_ent, destination,
12697                                                 local_off);
12698
12699                   if (stub_type != ppc_stub_plt_call)
12700                     {
12701                       /* Check whether we need a TOC adjusting stub.
12702                          Since the linker pastes together pieces from
12703                          different object files when creating the
12704                          _init and _fini functions, it may be that a
12705                          call to what looks like a local sym is in
12706                          fact a call needing a TOC adjustment.  */
12707                       if (code_sec != NULL
12708                           && code_sec->output_section != NULL
12709                           && (htab->sec_info[code_sec->id].toc_off
12710                               != htab->sec_info[section->id].toc_off)
12711                           && (code_sec->has_toc_reloc
12712                               || code_sec->makes_toc_func_call))
12713                         stub_type = ppc_stub_long_branch_r2off;
12714                     }
12715
12716                   if (stub_type == ppc_stub_none)
12717                     continue;
12718
12719                   /* __tls_get_addr calls might be eliminated.  */
12720                   if (stub_type != ppc_stub_plt_call
12721                       && hash != NULL
12722                       && (hash == htab->tls_get_addr
12723                           || hash == htab->tls_get_addr_fd)
12724                       && section->has_tls_reloc
12725                       && irela != internal_relocs)
12726                     {
12727                       /* Get tls info.  */
12728                       unsigned char *tls_mask;
12729
12730                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12731                                          irela - 1, input_bfd))
12732                         goto error_ret_free_internal;
12733                       if (*tls_mask != 0)
12734                         continue;
12735                     }
12736
12737                   if (stub_type == ppc_stub_plt_call)
12738                     {
12739                       if (!htab->opd_abi
12740                           && htab->params->plt_localentry0 != 0
12741                           && is_elfv2_localentry0 (&hash->elf))
12742                         htab->has_plt_localentry0 = 1;
12743                       else if (irela + 1 < irelaend
12744                                && irela[1].r_offset == irela->r_offset + 4
12745                                && (ELF64_R_TYPE (irela[1].r_info)
12746                                    == R_PPC64_TOCSAVE))
12747                         {
12748                           if (!tocsave_find (htab, INSERT,
12749                                              &local_syms, irela + 1, input_bfd))
12750                             goto error_ret_free_internal;
12751                         }
12752                       else
12753                         stub_type = ppc_stub_plt_call_r2save;
12754                     }
12755
12756                   /* Support for grouping stub sections.  */
12757                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12758
12759                   /* Get the name of this stub.  */
12760                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12761                   if (!stub_name)
12762                     goto error_ret_free_internal;
12763
12764                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12765                                                      stub_name, FALSE, FALSE);
12766                   if (stub_entry != NULL)
12767                     {
12768                       /* The proper stub has already been created.  */
12769                       free (stub_name);
12770                       if (stub_type == ppc_stub_plt_call_r2save)
12771                         stub_entry->stub_type = stub_type;
12772                       continue;
12773                     }
12774
12775                   stub_entry = ppc_add_stub (stub_name, section, info);
12776                   if (stub_entry == NULL)
12777                     {
12778                       free (stub_name);
12779                     error_ret_free_internal:
12780                       if (elf_section_data (section)->relocs == NULL)
12781                         free (internal_relocs);
12782                     error_ret_free_local:
12783                       if (local_syms != NULL
12784                           && (symtab_hdr->contents
12785                               != (unsigned char *) local_syms))
12786                         free (local_syms);
12787                       return FALSE;
12788                     }
12789
12790                   stub_entry->stub_type = stub_type;
12791                   if (stub_type != ppc_stub_plt_call
12792                       && stub_type != ppc_stub_plt_call_r2save)
12793                     {
12794                       stub_entry->target_value = code_value;
12795                       stub_entry->target_section = code_sec;
12796                     }
12797                   else
12798                     {
12799                       stub_entry->target_value = sym_value;
12800                       stub_entry->target_section = sym_sec;
12801                     }
12802                   stub_entry->h = hash;
12803                   stub_entry->plt_ent = plt_ent;
12804                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12805
12806                   if (stub_entry->h != NULL)
12807                     htab->stub_globals += 1;
12808                 }
12809
12810               /* We're done with the internal relocs, free them.  */
12811               if (elf_section_data (section)->relocs != internal_relocs)
12812                 free (internal_relocs);
12813             }
12814
12815           if (local_syms != NULL
12816               && symtab_hdr->contents != (unsigned char *) local_syms)
12817             {
12818               if (!info->keep_memory)
12819                 free (local_syms);
12820               else
12821                 symtab_hdr->contents = (unsigned char *) local_syms;
12822             }
12823         }
12824
12825       /* We may have added some stubs.  Find out the new size of the
12826          stub sections.  */
12827       for (group = htab->group; group != NULL; group = group->next)
12828         if (group->stub_sec != NULL)
12829           {
12830             asection *stub_sec = group->stub_sec;
12831
12832             if (htab->stub_iteration <= STUB_SHRINK_ITER
12833                 || stub_sec->rawsize < stub_sec->size)
12834               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12835               stub_sec->rawsize = stub_sec->size;
12836             stub_sec->size = 0;
12837             stub_sec->reloc_count = 0;
12838             stub_sec->flags &= ~SEC_RELOC;
12839           }
12840
12841       htab->brlt->size = 0;
12842       htab->brlt->reloc_count = 0;
12843       htab->brlt->flags &= ~SEC_RELOC;
12844       if (htab->relbrlt != NULL)
12845         htab->relbrlt->size = 0;
12846
12847       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12848
12849       for (group = htab->group; group != NULL; group = group->next)
12850         if (group->needs_save_res)
12851           group->stub_sec->size += htab->sfpr->size;
12852
12853       if (info->emitrelocations
12854           && htab->glink != NULL && htab->glink->size != 0)
12855         {
12856           htab->glink->reloc_count = 1;
12857           htab->glink->flags |= SEC_RELOC;
12858         }
12859
12860       if (htab->glink_eh_frame != NULL
12861           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12862           && htab->glink_eh_frame->output_section->size != 0)
12863         {
12864           size_t size = 0, align = 4;
12865
12866           for (group = htab->group; group != NULL; group = group->next)
12867             if (group->stub_sec != NULL)
12868               size += stub_eh_frame_size (group, align);
12869           if (htab->glink != NULL && htab->glink->size != 0)
12870             size += (24 + align - 1) & -align;
12871           if (size != 0)
12872             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12873           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12874           size = (size + align - 1) & -align;
12875           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12876           htab->glink_eh_frame->size = size;
12877         }
12878
12879       if (htab->params->plt_stub_align != 0)
12880         for (group = htab->group; group != NULL; group = group->next)
12881           if (group->stub_sec != NULL)
12882             group->stub_sec->size = ((group->stub_sec->size
12883                                       + (1 << htab->params->plt_stub_align) - 1)
12884                                      & -(1 << htab->params->plt_stub_align));
12885
12886       for (group = htab->group; group != NULL; group = group->next)
12887         if (group->stub_sec != NULL
12888             && group->stub_sec->rawsize != group->stub_sec->size
12889             && (htab->stub_iteration <= STUB_SHRINK_ITER
12890                 || group->stub_sec->rawsize < group->stub_sec->size))
12891           break;
12892
12893       if (group == NULL
12894           && (htab->glink_eh_frame == NULL
12895               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12896         break;
12897
12898       /* Ask the linker to do its stuff.  */
12899       (*htab->params->layout_sections_again) ();
12900     }
12901
12902   if (htab->glink_eh_frame != NULL
12903       && htab->glink_eh_frame->size != 0)
12904     {
12905       bfd_vma val;
12906       bfd_byte *p, *last_fde;
12907       size_t last_fde_len, size, align, pad;
12908       struct map_stub *group;
12909
12910       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12911       if (p == NULL)
12912         return FALSE;
12913       htab->glink_eh_frame->contents = p;
12914       last_fde = p;
12915       align = 4;
12916
12917       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12918       /* CIE length (rewrite in case little-endian).  */
12919       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12920       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12921       p += last_fde_len + 4;
12922
12923       for (group = htab->group; group != NULL; group = group->next)
12924         if (group->stub_sec != NULL)
12925           {
12926             last_fde = p;
12927             last_fde_len = stub_eh_frame_size (group, align) - 4;
12928             /* FDE length.  */
12929             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12930             p += 4;
12931             /* CIE pointer.  */
12932             val = p - htab->glink_eh_frame->contents;
12933             bfd_put_32 (htab->elf.dynobj, val, p);
12934             p += 4;
12935             /* Offset to stub section, written later.  */
12936             p += 4;
12937             /* stub section size.  */
12938             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12939             p += 4;
12940             /* Augmentation.  */
12941             p += 1;
12942             if (group->tls_get_addr_opt_bctrl != -1u)
12943               {
12944                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12945
12946                 /* This FDE needs more than just the default.
12947                    Describe __tls_get_addr_opt stub LR.  */
12948                 if (to_bctrl < 64)
12949                   *p++ = DW_CFA_advance_loc + to_bctrl;
12950                 else if (to_bctrl < 256)
12951                   {
12952                     *p++ = DW_CFA_advance_loc1;
12953                     *p++ = to_bctrl;
12954                   }
12955                 else if (to_bctrl < 65536)
12956                   {
12957                     *p++ = DW_CFA_advance_loc2;
12958                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12959                     p += 2;
12960                   }
12961                 else
12962                   {
12963                     *p++ = DW_CFA_advance_loc4;
12964                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12965                     p += 4;
12966                   }
12967                 *p++ = DW_CFA_offset_extended_sf;
12968                 *p++ = 65;
12969                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12970                 *p++ = DW_CFA_advance_loc + 4;
12971                 *p++ = DW_CFA_restore_extended;
12972                 *p++ = 65;
12973               }
12974             /* Pad.  */
12975             p = last_fde + last_fde_len + 4;
12976           }
12977       if (htab->glink != NULL && htab->glink->size != 0)
12978         {
12979           last_fde = p;
12980           last_fde_len = ((24 + align - 1) & -align) - 4;
12981           /* FDE length.  */
12982           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12983           p += 4;
12984           /* CIE pointer.  */
12985           val = p - htab->glink_eh_frame->contents;
12986           bfd_put_32 (htab->elf.dynobj, val, p);
12987           p += 4;
12988           /* Offset to .glink, written later.  */
12989           p += 4;
12990           /* .glink size.  */
12991           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12992           p += 4;
12993           /* Augmentation.  */
12994           p += 1;
12995
12996           *p++ = DW_CFA_advance_loc + 1;
12997           *p++ = DW_CFA_register;
12998           *p++ = 65;
12999           *p++ = htab->opd_abi ? 12 : 0;
13000           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13001           *p++ = DW_CFA_restore_extended;
13002           *p++ = 65;
13003           p += ((24 + align - 1) & -align) - 24;
13004         }
13005       /* Subsume any padding into the last FDE if user .eh_frame
13006          sections are aligned more than glink_eh_frame.  Otherwise any
13007          zero padding will be seen as a terminator.  */
13008       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13009       size = p - htab->glink_eh_frame->contents;
13010       pad = ((size + align - 1) & -align) - size;
13011       htab->glink_eh_frame->size = size + pad;
13012       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13013     }
13014
13015   maybe_strip_output (info, htab->brlt);
13016   if (htab->glink_eh_frame != NULL)
13017     maybe_strip_output (info, htab->glink_eh_frame);
13018
13019   return TRUE;
13020 }
13021
13022 /* Called after we have determined section placement.  If sections
13023    move, we'll be called again.  Provide a value for TOCstart.  */
13024
13025 bfd_vma
13026 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13027 {
13028   asection *s;
13029   bfd_vma TOCstart, adjust;
13030
13031   if (info != NULL)
13032     {
13033       struct elf_link_hash_entry *h;
13034       struct elf_link_hash_table *htab = elf_hash_table (info);
13035
13036       if (is_elf_hash_table (htab)
13037           && htab->hgot != NULL)
13038         h = htab->hgot;
13039       else
13040         {
13041           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13042           if (is_elf_hash_table (htab))
13043             htab->hgot = h;
13044         }
13045       if (h != NULL
13046           && h->root.type == bfd_link_hash_defined
13047           && !h->root.linker_def
13048           && (!is_elf_hash_table (htab)
13049               || h->def_regular))
13050         {
13051           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13052                       + h->root.u.def.section->output_offset
13053                       + h->root.u.def.section->output_section->vma);
13054           _bfd_set_gp_value (obfd, TOCstart);
13055           return TOCstart;
13056         }
13057     }
13058
13059   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13060      order.  The TOC starts where the first of these sections starts.  */
13061   s = bfd_get_section_by_name (obfd, ".got");
13062   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13063     s = bfd_get_section_by_name (obfd, ".toc");
13064   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13065     s = bfd_get_section_by_name (obfd, ".tocbss");
13066   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13067     s = bfd_get_section_by_name (obfd, ".plt");
13068   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13069     {
13070       /* This may happen for
13071          o  references to TOC base (SYM@toc / TOC[tc0]) without a
13072          .toc directive
13073          o  bad linker script
13074          o --gc-sections and empty TOC sections
13075
13076          FIXME: Warn user?  */
13077
13078       /* Look for a likely section.  We probably won't even be
13079          using TOCstart.  */
13080       for (s = obfd->sections; s != NULL; s = s->next)
13081         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13082                          | SEC_EXCLUDE))
13083             == (SEC_ALLOC | SEC_SMALL_DATA))
13084           break;
13085       if (s == NULL)
13086         for (s = obfd->sections; s != NULL; s = s->next)
13087           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13088               == (SEC_ALLOC | SEC_SMALL_DATA))
13089             break;
13090       if (s == NULL)
13091         for (s = obfd->sections; s != NULL; s = s->next)
13092           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13093               == SEC_ALLOC)
13094             break;
13095       if (s == NULL)
13096         for (s = obfd->sections; s != NULL; s = s->next)
13097           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13098             break;
13099     }
13100
13101   TOCstart = 0;
13102   if (s != NULL)
13103     TOCstart = s->output_section->vma + s->output_offset;
13104
13105   /* Force alignment.  */
13106   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13107   TOCstart -= adjust;
13108   _bfd_set_gp_value (obfd, TOCstart);
13109
13110   if (info != NULL && s != NULL)
13111     {
13112       struct ppc_link_hash_table *htab = ppc_hash_table (info);
13113
13114       if (htab != NULL)
13115         {
13116           if (htab->elf.hgot != NULL)
13117             {
13118               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13119               htab->elf.hgot->root.u.def.section = s;
13120             }
13121         }
13122       else
13123         {
13124           struct bfd_link_hash_entry *bh = NULL;
13125           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13126                                             s, TOC_BASE_OFF - adjust,
13127                                             NULL, FALSE, FALSE, &bh);
13128         }
13129     }
13130   return TOCstart;
13131 }
13132
13133 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13134    write out any global entry stubs.  */
13135
13136 static bfd_boolean
13137 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13138 {
13139   struct bfd_link_info *info;
13140   struct ppc_link_hash_table *htab;
13141   struct plt_entry *pent;
13142   asection *s;
13143
13144   if (h->root.type == bfd_link_hash_indirect)
13145     return TRUE;
13146
13147   if (!h->pointer_equality_needed)
13148     return TRUE;
13149
13150   if (h->def_regular)
13151     return TRUE;
13152
13153   info = inf;
13154   htab = ppc_hash_table (info);
13155   if (htab == NULL)
13156     return FALSE;
13157
13158   s = htab->glink;
13159   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13160     if (pent->plt.offset != (bfd_vma) -1
13161         && pent->addend == 0)
13162       {
13163         bfd_byte *p;
13164         asection *plt;
13165         bfd_vma off;
13166
13167         p = s->contents + h->root.u.def.value;
13168         plt = htab->elf.splt;
13169         if (!htab->elf.dynamic_sections_created
13170             || h->dynindx == -1)
13171           plt = htab->elf.iplt;
13172         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13173         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13174
13175         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13176           {
13177             info->callbacks->einfo
13178               (_("%P: linkage table error against `%T'\n"),
13179                h->root.root.string);
13180             bfd_set_error (bfd_error_bad_value);
13181             htab->stub_error = TRUE;
13182           }
13183
13184         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13185         if (htab->params->emit_stub_syms)
13186           {
13187             size_t len = strlen (h->root.root.string);
13188             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13189
13190             if (name == NULL)
13191               return FALSE;
13192
13193             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13194             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13195             if (h == NULL)
13196               return FALSE;
13197             if (h->root.type == bfd_link_hash_new)
13198               {
13199                 h->root.type = bfd_link_hash_defined;
13200                 h->root.u.def.section = s;
13201                 h->root.u.def.value = p - s->contents;
13202                 h->ref_regular = 1;
13203                 h->def_regular = 1;
13204                 h->ref_regular_nonweak = 1;
13205                 h->forced_local = 1;
13206                 h->non_elf = 0;
13207                 h->root.linker_def = 1;
13208               }
13209           }
13210
13211         if (PPC_HA (off) != 0)
13212           {
13213             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13214             p += 4;
13215           }
13216         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13217         p += 4;
13218         bfd_put_32 (s->owner, MTCTR_R12, p);
13219         p += 4;
13220         bfd_put_32 (s->owner, BCTR, p);
13221         break;
13222       }
13223   return TRUE;
13224 }
13225
13226 /* Build all the stubs associated with the current output file.
13227    The stubs are kept in a hash table attached to the main linker
13228    hash table.  This function is called via gldelf64ppc_finish.  */
13229
13230 bfd_boolean
13231 ppc64_elf_build_stubs (struct bfd_link_info *info,
13232                        char **stats)
13233 {
13234   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13235   struct map_stub *group;
13236   asection *stub_sec;
13237   bfd_byte *p;
13238   int stub_sec_count = 0;
13239
13240   if (htab == NULL)
13241     return FALSE;
13242
13243   /* Allocate memory to hold the linker stubs.  */
13244   for (group = htab->group; group != NULL; group = group->next)
13245     if ((stub_sec = group->stub_sec) != NULL
13246         && stub_sec->size != 0)
13247       {
13248         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13249         if (stub_sec->contents == NULL)
13250           return FALSE;
13251         stub_sec->size = 0;
13252       }
13253
13254   if (htab->glink != NULL && htab->glink->size != 0)
13255     {
13256       unsigned int indx;
13257       bfd_vma plt0;
13258
13259       /* Build the .glink plt call stub.  */
13260       if (htab->params->emit_stub_syms)
13261         {
13262           struct elf_link_hash_entry *h;
13263           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13264                                     TRUE, FALSE, FALSE);
13265           if (h == NULL)
13266             return FALSE;
13267           if (h->root.type == bfd_link_hash_new)
13268             {
13269               h->root.type = bfd_link_hash_defined;
13270               h->root.u.def.section = htab->glink;
13271               h->root.u.def.value = 8;
13272               h->ref_regular = 1;
13273               h->def_regular = 1;
13274               h->ref_regular_nonweak = 1;
13275               h->forced_local = 1;
13276               h->non_elf = 0;
13277               h->root.linker_def = 1;
13278             }
13279         }
13280       plt0 = (htab->elf.splt->output_section->vma
13281               + htab->elf.splt->output_offset
13282               - 16);
13283       if (info->emitrelocations)
13284         {
13285           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13286           if (r == NULL)
13287             return FALSE;
13288           r->r_offset = (htab->glink->output_offset
13289                          + htab->glink->output_section->vma);
13290           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13291           r->r_addend = plt0;
13292         }
13293       p = htab->glink->contents;
13294       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13295       bfd_put_64 (htab->glink->owner, plt0, p);
13296       p += 8;
13297       if (htab->opd_abi)
13298         {
13299           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13300           p += 4;
13301           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13302           p += 4;
13303           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13304           p += 4;
13305           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13306           p += 4;
13307           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13308           p += 4;
13309           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13310           p += 4;
13311           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13312           p += 4;
13313           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13314           p += 4;
13315           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13316           p += 4;
13317           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13318           p += 4;
13319         }
13320       else
13321         {
13322           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13323           p += 4;
13324           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13325           p += 4;
13326           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13327           p += 4;
13328           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13329           p += 4;
13330           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13331           p += 4;
13332           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13333           p += 4;
13334           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13335           p += 4;
13336           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13337           p += 4;
13338           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13339           p += 4;
13340           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13341           p += 4;
13342           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13343           p += 4;
13344           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13345           p += 4;
13346           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13347           p += 4;
13348         }
13349       bfd_put_32 (htab->glink->owner, BCTR, p);
13350       p += 4;
13351       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13352         {
13353           bfd_put_32 (htab->glink->owner, NOP, p);
13354           p += 4;
13355         }
13356
13357       /* Build the .glink lazy link call stubs.  */
13358       indx = 0;
13359       while (p < htab->glink->contents + htab->glink->rawsize)
13360         {
13361           if (htab->opd_abi)
13362             {
13363               if (indx < 0x8000)
13364                 {
13365                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13366                   p += 4;
13367                 }
13368               else
13369                 {
13370                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13371                   p += 4;
13372                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13373                               p);
13374                   p += 4;
13375                 }
13376             }
13377           bfd_put_32 (htab->glink->owner,
13378                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13379           indx++;
13380           p += 4;
13381         }
13382
13383       /* Build .glink global entry stubs.  */
13384       if (htab->glink->size > htab->glink->rawsize)
13385         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13386     }
13387
13388   if (htab->brlt != NULL && htab->brlt->size != 0)
13389     {
13390       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13391                                          htab->brlt->size);
13392       if (htab->brlt->contents == NULL)
13393         return FALSE;
13394     }
13395   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13396     {
13397       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13398                                             htab->relbrlt->size);
13399       if (htab->relbrlt->contents == NULL)
13400         return FALSE;
13401     }
13402
13403   /* Build the stubs as directed by the stub hash table.  */
13404   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13405
13406   for (group = htab->group; group != NULL; group = group->next)
13407     if (group->needs_save_res)
13408       {
13409         stub_sec = group->stub_sec;
13410         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13411                 htab->sfpr->size);
13412         if (htab->params->emit_stub_syms)
13413           {
13414             unsigned int i;
13415
13416             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13417               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13418                 return FALSE;
13419           }
13420         stub_sec->size += htab->sfpr->size;
13421       }
13422
13423   if (htab->relbrlt != NULL)
13424     htab->relbrlt->reloc_count = 0;
13425
13426   if (htab->params->plt_stub_align != 0)
13427     for (group = htab->group; group != NULL; group = group->next)
13428       if ((stub_sec = group->stub_sec) != NULL)
13429         stub_sec->size = ((stub_sec->size
13430                            + (1 << htab->params->plt_stub_align) - 1)
13431                           & -(1 << htab->params->plt_stub_align));
13432
13433   for (group = htab->group; group != NULL; group = group->next)
13434     if ((stub_sec = group->stub_sec) != NULL)
13435       {
13436         stub_sec_count += 1;
13437         if (stub_sec->rawsize != stub_sec->size
13438             && (htab->stub_iteration <= STUB_SHRINK_ITER
13439                 || stub_sec->rawsize < stub_sec->size))
13440           break;
13441       }
13442
13443   if (group != NULL)
13444     {
13445       htab->stub_error = TRUE;
13446       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13447     }
13448
13449   if (htab->stub_error)
13450     return FALSE;
13451
13452   if (stats != NULL)
13453     {
13454       *stats = bfd_malloc (500);
13455       if (*stats == NULL)
13456         return FALSE;
13457
13458       sprintf (*stats, _("linker stubs in %u group%s\n"
13459                          "  branch       %lu\n"
13460                          "  toc adjust   %lu\n"
13461                          "  long branch  %lu\n"
13462                          "  long toc adj %lu\n"
13463                          "  plt call     %lu\n"
13464                          "  plt call toc %lu\n"
13465                          "  global entry %lu"),
13466                stub_sec_count,
13467                stub_sec_count == 1 ? "" : "s",
13468                htab->stub_count[ppc_stub_long_branch - 1],
13469                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13470                htab->stub_count[ppc_stub_plt_branch - 1],
13471                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13472                htab->stub_count[ppc_stub_plt_call - 1],
13473                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13474                htab->stub_count[ppc_stub_global_entry - 1]);
13475     }
13476   return TRUE;
13477 }
13478
13479 /* What to do when ld finds relocations against symbols defined in
13480    discarded sections.  */
13481
13482 static unsigned int
13483 ppc64_elf_action_discarded (asection *sec)
13484 {
13485   if (strcmp (".opd", sec->name) == 0)
13486     return 0;
13487
13488   if (strcmp (".toc", sec->name) == 0)
13489     return 0;
13490
13491   if (strcmp (".toc1", sec->name) == 0)
13492     return 0;
13493
13494   return _bfd_elf_default_action_discarded (sec);
13495 }
13496
13497 /* The RELOCATE_SECTION function is called by the ELF backend linker
13498    to handle the relocations for a section.
13499
13500    The relocs are always passed as Rela structures; if the section
13501    actually uses Rel structures, the r_addend field will always be
13502    zero.
13503
13504    This function is responsible for adjust the section contents as
13505    necessary, and (if using Rela relocs and generating a
13506    relocatable output file) adjusting the reloc addend as
13507    necessary.
13508
13509    This function does not have to worry about setting the reloc
13510    address or the reloc symbol index.
13511
13512    LOCAL_SYMS is a pointer to the swapped in local symbols.
13513
13514    LOCAL_SECTIONS is an array giving the section in the input file
13515    corresponding to the st_shndx field of each local symbol.
13516
13517    The global hash table entry for the global symbols can be found
13518    via elf_sym_hashes (input_bfd).
13519
13520    When generating relocatable output, this function must handle
13521    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13522    going to be the section symbol corresponding to the output
13523    section, which means that the addend must be adjusted
13524    accordingly.  */
13525
13526 static bfd_boolean
13527 ppc64_elf_relocate_section (bfd *output_bfd,
13528                             struct bfd_link_info *info,
13529                             bfd *input_bfd,
13530                             asection *input_section,
13531                             bfd_byte *contents,
13532                             Elf_Internal_Rela *relocs,
13533                             Elf_Internal_Sym *local_syms,
13534                             asection **local_sections)
13535 {
13536   struct ppc_link_hash_table *htab;
13537   Elf_Internal_Shdr *symtab_hdr;
13538   struct elf_link_hash_entry **sym_hashes;
13539   Elf_Internal_Rela *rel;
13540   Elf_Internal_Rela *wrel;
13541   Elf_Internal_Rela *relend;
13542   Elf_Internal_Rela outrel;
13543   bfd_byte *loc;
13544   struct got_entry **local_got_ents;
13545   bfd_vma TOCstart;
13546   bfd_boolean ret = TRUE;
13547   bfd_boolean is_opd;
13548   /* Assume 'at' branch hints.  */
13549   bfd_boolean is_isa_v2 = TRUE;
13550   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13551
13552   /* Initialize howto table if needed.  */
13553   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13554     ppc_howto_init ();
13555
13556   htab = ppc_hash_table (info);
13557   if (htab == NULL)
13558     return FALSE;
13559
13560   /* Don't relocate stub sections.  */
13561   if (input_section->owner == htab->params->stub_bfd)
13562     return TRUE;
13563
13564   BFD_ASSERT (is_ppc64_elf (input_bfd));
13565
13566   local_got_ents = elf_local_got_ents (input_bfd);
13567   TOCstart = elf_gp (output_bfd);
13568   symtab_hdr = &elf_symtab_hdr (input_bfd);
13569   sym_hashes = elf_sym_hashes (input_bfd);
13570   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13571
13572   rel = wrel = relocs;
13573   relend = relocs + input_section->reloc_count;
13574   for (; rel < relend; wrel++, rel++)
13575     {
13576       enum elf_ppc64_reloc_type r_type;
13577       bfd_vma addend;
13578       bfd_reloc_status_type r;
13579       Elf_Internal_Sym *sym;
13580       asection *sec;
13581       struct elf_link_hash_entry *h_elf;
13582       struct ppc_link_hash_entry *h;
13583       struct ppc_link_hash_entry *fdh;
13584       const char *sym_name;
13585       unsigned long r_symndx, toc_symndx;
13586       bfd_vma toc_addend;
13587       unsigned char tls_mask, tls_gd, tls_type;
13588       unsigned char sym_type;
13589       bfd_vma relocation;
13590       bfd_boolean unresolved_reloc;
13591       bfd_boolean warned;
13592       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13593       unsigned int insn;
13594       unsigned int mask;
13595       struct ppc_stub_hash_entry *stub_entry;
13596       bfd_vma max_br_offset;
13597       bfd_vma from;
13598       Elf_Internal_Rela orig_rel;
13599       reloc_howto_type *howto;
13600       struct reloc_howto_struct alt_howto;
13601
13602     again:
13603       orig_rel = *rel;
13604
13605       r_type = ELF64_R_TYPE (rel->r_info);
13606       r_symndx = ELF64_R_SYM (rel->r_info);
13607
13608       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13609          symbol of the previous ADDR64 reloc.  The symbol gives us the
13610          proper TOC base to use.  */
13611       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13612           && wrel != relocs
13613           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13614           && is_opd)
13615         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13616
13617       sym = NULL;
13618       sec = NULL;
13619       h_elf = NULL;
13620       sym_name = NULL;
13621       unresolved_reloc = FALSE;
13622       warned = FALSE;
13623
13624       if (r_symndx < symtab_hdr->sh_info)
13625         {
13626           /* It's a local symbol.  */
13627           struct _opd_sec_data *opd;
13628
13629           sym = local_syms + r_symndx;
13630           sec = local_sections[r_symndx];
13631           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13632           sym_type = ELF64_ST_TYPE (sym->st_info);
13633           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13634           opd = get_opd_info (sec);
13635           if (opd != NULL && opd->adjust != NULL)
13636             {
13637               long adjust = opd->adjust[OPD_NDX (sym->st_value
13638                                                  + rel->r_addend)];
13639               if (adjust == -1)
13640                 relocation = 0;
13641               else
13642                 {
13643                   /* If this is a relocation against the opd section sym
13644                      and we have edited .opd, adjust the reloc addend so
13645                      that ld -r and ld --emit-relocs output is correct.
13646                      If it is a reloc against some other .opd symbol,
13647                      then the symbol value will be adjusted later.  */
13648                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13649                     rel->r_addend += adjust;
13650                   else
13651                     relocation += adjust;
13652                 }
13653             }
13654         }
13655       else
13656         {
13657           bfd_boolean ignored;
13658
13659           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13660                                    r_symndx, symtab_hdr, sym_hashes,
13661                                    h_elf, sec, relocation,
13662                                    unresolved_reloc, warned, ignored);
13663           sym_name = h_elf->root.root.string;
13664           sym_type = h_elf->type;
13665           if (sec != NULL
13666               && sec->owner == output_bfd
13667               && strcmp (sec->name, ".opd") == 0)
13668             {
13669               /* This is a symbol defined in a linker script.  All
13670                  such are defined in output sections, even those
13671                  defined by simple assignment from a symbol defined in
13672                  an input section.  Transfer the symbol to an
13673                  appropriate input .opd section, so that a branch to
13674                  this symbol will be mapped to the location specified
13675                  by the opd entry.  */
13676               struct bfd_link_order *lo;
13677               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13678                 if (lo->type == bfd_indirect_link_order)
13679                   {
13680                     asection *isec = lo->u.indirect.section;
13681                     if (h_elf->root.u.def.value >= isec->output_offset
13682                         && h_elf->root.u.def.value < (isec->output_offset
13683                                                       + isec->size))
13684                       {
13685                         h_elf->root.u.def.value -= isec->output_offset;
13686                         h_elf->root.u.def.section = isec;
13687                         sec = isec;
13688                         break;
13689                       }
13690                   }
13691             }
13692         }
13693       h = (struct ppc_link_hash_entry *) h_elf;
13694
13695       if (sec != NULL && discarded_section (sec))
13696         {
13697           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13698                                input_bfd, input_section,
13699                                contents + rel->r_offset);
13700           wrel->r_offset = rel->r_offset;
13701           wrel->r_info = 0;
13702           wrel->r_addend = 0;
13703
13704           /* For ld -r, remove relocations in debug sections against
13705              symbols defined in discarded sections.  Not done for
13706              non-debug to preserve relocs in .eh_frame which the
13707              eh_frame editing code expects to be present.  */
13708           if (bfd_link_relocatable (info)
13709               && (input_section->flags & SEC_DEBUGGING))
13710             wrel--;
13711
13712           continue;
13713         }
13714
13715       if (bfd_link_relocatable (info))
13716         goto copy_reloc;
13717
13718       if (h != NULL && &h->elf == htab->elf.hgot)
13719         {
13720           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13721           sec = bfd_abs_section_ptr;
13722           unresolved_reloc = FALSE;
13723         }
13724
13725       /* TLS optimizations.  Replace instruction sequences and relocs
13726          based on information we collected in tls_optimize.  We edit
13727          RELOCS so that --emit-relocs will output something sensible
13728          for the final instruction stream.  */
13729       tls_mask = 0;
13730       tls_gd = 0;
13731       toc_symndx = 0;
13732       if (h != NULL)
13733         tls_mask = h->tls_mask;
13734       else if (local_got_ents != NULL)
13735         {
13736           struct plt_entry **local_plt = (struct plt_entry **)
13737             (local_got_ents + symtab_hdr->sh_info);
13738           unsigned char *lgot_masks = (unsigned char *)
13739             (local_plt + symtab_hdr->sh_info);
13740           tls_mask = lgot_masks[r_symndx];
13741         }
13742       if (tls_mask == 0
13743           && (r_type == R_PPC64_TLS
13744               || r_type == R_PPC64_TLSGD
13745               || r_type == R_PPC64_TLSLD))
13746         {
13747           /* Check for toc tls entries.  */
13748           unsigned char *toc_tls;
13749
13750           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13751                              &local_syms, rel, input_bfd))
13752             return FALSE;
13753
13754           if (toc_tls)
13755             tls_mask = *toc_tls;
13756         }
13757
13758       /* Check that tls relocs are used with tls syms, and non-tls
13759          relocs are used with non-tls syms.  */
13760       if (r_symndx != STN_UNDEF
13761           && r_type != R_PPC64_NONE
13762           && (h == NULL
13763               || h->elf.root.type == bfd_link_hash_defined
13764               || h->elf.root.type == bfd_link_hash_defweak)
13765           && (IS_PPC64_TLS_RELOC (r_type)
13766               != (sym_type == STT_TLS
13767                   || (sym_type == STT_SECTION
13768                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13769         {
13770           if (tls_mask != 0
13771               && (r_type == R_PPC64_TLS
13772                   || r_type == R_PPC64_TLSGD
13773                   || r_type == R_PPC64_TLSLD))
13774             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13775             ;
13776           else
13777             info->callbacks->einfo
13778               (!IS_PPC64_TLS_RELOC (r_type)
13779                /* xgettext:c-format */
13780                ? _("%H: %s used with TLS symbol `%T'\n")
13781                /* xgettext:c-format */
13782                : _("%H: %s used with non-TLS symbol `%T'\n"),
13783                input_bfd, input_section, rel->r_offset,
13784                ppc64_elf_howto_table[r_type]->name,
13785                sym_name);
13786         }
13787
13788       /* Ensure reloc mapping code below stays sane.  */
13789       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13790           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13791           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13792           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13793           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13794           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13795           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13796           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13797           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13798           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13799         abort ();
13800
13801       switch (r_type)
13802         {
13803         default:
13804           break;
13805
13806         case R_PPC64_LO_DS_OPT:
13807           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13808           if ((insn & (0x3f << 26)) != 58u << 26)
13809             abort ();
13810           insn += (14u << 26) - (58u << 26);
13811           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13812           r_type = R_PPC64_TOC16_LO;
13813           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13814           break;
13815
13816         case R_PPC64_TOC16:
13817         case R_PPC64_TOC16_LO:
13818         case R_PPC64_TOC16_DS:
13819         case R_PPC64_TOC16_LO_DS:
13820           {
13821             /* Check for toc tls entries.  */
13822             unsigned char *toc_tls;
13823             int retval;
13824
13825             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13826                                    &local_syms, rel, input_bfd);
13827             if (retval == 0)
13828               return FALSE;
13829
13830             if (toc_tls)
13831               {
13832                 tls_mask = *toc_tls;
13833                 if (r_type == R_PPC64_TOC16_DS
13834                     || r_type == R_PPC64_TOC16_LO_DS)
13835                   {
13836                     if (tls_mask != 0
13837                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13838                       goto toctprel;
13839                   }
13840                 else
13841                   {
13842                     /* If we found a GD reloc pair, then we might be
13843                        doing a GD->IE transition.  */
13844                     if (retval == 2)
13845                       {
13846                         tls_gd = TLS_TPRELGD;
13847                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13848                           goto tls_ldgd_opt;
13849                       }
13850                     else if (retval == 3)
13851                       {
13852                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13853                           goto tls_ldgd_opt;
13854                       }
13855                   }
13856               }
13857           }
13858           break;
13859
13860         case R_PPC64_GOT_TPREL16_HI:
13861         case R_PPC64_GOT_TPREL16_HA:
13862           if (tls_mask != 0
13863               && (tls_mask & TLS_TPREL) == 0)
13864             {
13865               rel->r_offset -= d_offset;
13866               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13867               r_type = R_PPC64_NONE;
13868               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13869             }
13870           break;
13871
13872         case R_PPC64_GOT_TPREL16_DS:
13873         case R_PPC64_GOT_TPREL16_LO_DS:
13874           if (tls_mask != 0
13875               && (tls_mask & TLS_TPREL) == 0)
13876             {
13877             toctprel:
13878               insn = bfd_get_32 (input_bfd,
13879                                  contents + rel->r_offset - d_offset);
13880               insn &= 31 << 21;
13881               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13882               bfd_put_32 (input_bfd, insn,
13883                           contents + rel->r_offset - d_offset);
13884               r_type = R_PPC64_TPREL16_HA;
13885               if (toc_symndx != 0)
13886                 {
13887                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13888                   rel->r_addend = toc_addend;
13889                   /* We changed the symbol.  Start over in order to
13890                      get h, sym, sec etc. right.  */
13891                   goto again;
13892                 }
13893               else
13894                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13895             }
13896           break;
13897
13898         case R_PPC64_TLS:
13899           if (tls_mask != 0
13900               && (tls_mask & TLS_TPREL) == 0)
13901             {
13902               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13903               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13904               if (insn == 0)
13905                 abort ();
13906               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13907               /* Was PPC64_TLS which sits on insn boundary, now
13908                  PPC64_TPREL16_LO which is at low-order half-word.  */
13909               rel->r_offset += d_offset;
13910               r_type = R_PPC64_TPREL16_LO;
13911               if (toc_symndx != 0)
13912                 {
13913                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13914                   rel->r_addend = toc_addend;
13915                   /* We changed the symbol.  Start over in order to
13916                      get h, sym, sec etc. right.  */
13917                   goto again;
13918                 }
13919               else
13920                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13921             }
13922           break;
13923
13924         case R_PPC64_GOT_TLSGD16_HI:
13925         case R_PPC64_GOT_TLSGD16_HA:
13926           tls_gd = TLS_TPRELGD;
13927           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13928             goto tls_gdld_hi;
13929           break;
13930
13931         case R_PPC64_GOT_TLSLD16_HI:
13932         case R_PPC64_GOT_TLSLD16_HA:
13933           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13934             {
13935             tls_gdld_hi:
13936               if ((tls_mask & tls_gd) != 0)
13937                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13938                           + R_PPC64_GOT_TPREL16_DS);
13939               else
13940                 {
13941                   rel->r_offset -= d_offset;
13942                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13943                   r_type = R_PPC64_NONE;
13944                 }
13945               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13946             }
13947           break;
13948
13949         case R_PPC64_GOT_TLSGD16:
13950         case R_PPC64_GOT_TLSGD16_LO:
13951           tls_gd = TLS_TPRELGD;
13952           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13953             goto tls_ldgd_opt;
13954           break;
13955
13956         case R_PPC64_GOT_TLSLD16:
13957         case R_PPC64_GOT_TLSLD16_LO:
13958           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13959             {
13960               unsigned int insn1, insn2;
13961               bfd_vma offset;
13962
13963             tls_ldgd_opt:
13964               offset = (bfd_vma) -1;
13965               /* If not using the newer R_PPC64_TLSGD/LD to mark
13966                  __tls_get_addr calls, we must trust that the call
13967                  stays with its arg setup insns, ie. that the next
13968                  reloc is the __tls_get_addr call associated with
13969                  the current reloc.  Edit both insns.  */
13970               if (input_section->has_tls_get_addr_call
13971                   && rel + 1 < relend
13972                   && branch_reloc_hash_match (input_bfd, rel + 1,
13973                                               htab->tls_get_addr,
13974                                               htab->tls_get_addr_fd))
13975                 offset = rel[1].r_offset;
13976               /* We read the low GOT_TLS (or TOC16) insn because we
13977                  need to keep the destination reg.  It may be
13978                  something other than the usual r3, and moved to r3
13979                  before the call by intervening code.  */
13980               insn1 = bfd_get_32 (input_bfd,
13981                                   contents + rel->r_offset - d_offset);
13982               if ((tls_mask & tls_gd) != 0)
13983                 {
13984                   /* IE */
13985                   insn1 &= (0x1f << 21) | (0x1f << 16);
13986                   insn1 |= 58 << 26;    /* ld */
13987                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13988                   if (offset != (bfd_vma) -1)
13989                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13990                   if ((tls_mask & TLS_EXPLICIT) == 0)
13991                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13992                               + R_PPC64_GOT_TPREL16_DS);
13993                   else
13994                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13995                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13996                 }
13997               else
13998                 {
13999                   /* LE */
14000                   insn1 &= 0x1f << 21;
14001                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
14002                   insn2 = 0x38630000;   /* addi 3,3,0 */
14003                   if (tls_gd == 0)
14004                     {
14005                       /* Was an LD reloc.  */
14006                       if (toc_symndx)
14007                         sec = local_sections[toc_symndx];
14008                       for (r_symndx = 0;
14009                            r_symndx < symtab_hdr->sh_info;
14010                            r_symndx++)
14011                         if (local_sections[r_symndx] == sec)
14012                           break;
14013                       if (r_symndx >= symtab_hdr->sh_info)
14014                         r_symndx = STN_UNDEF;
14015                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14016                       if (r_symndx != STN_UNDEF)
14017                         rel->r_addend -= (local_syms[r_symndx].st_value
14018                                           + sec->output_offset
14019                                           + sec->output_section->vma);
14020                     }
14021                   else if (toc_symndx != 0)
14022                     {
14023                       r_symndx = toc_symndx;
14024                       rel->r_addend = toc_addend;
14025                     }
14026                   r_type = R_PPC64_TPREL16_HA;
14027                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14028                   if (offset != (bfd_vma) -1)
14029                     {
14030                       rel[1].r_info = ELF64_R_INFO (r_symndx,
14031                                                     R_PPC64_TPREL16_LO);
14032                       rel[1].r_offset = offset + d_offset;
14033                       rel[1].r_addend = rel->r_addend;
14034                     }
14035                 }
14036               bfd_put_32 (input_bfd, insn1,
14037                           contents + rel->r_offset - d_offset);
14038               if (offset != (bfd_vma) -1)
14039                 bfd_put_32 (input_bfd, insn2, contents + offset);
14040               if ((tls_mask & tls_gd) == 0
14041                   && (tls_gd == 0 || toc_symndx != 0))
14042                 {
14043                   /* We changed the symbol.  Start over in order
14044                      to get h, sym, sec etc. right.  */
14045                   goto again;
14046                 }
14047             }
14048           break;
14049
14050         case R_PPC64_TLSGD:
14051           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
14052             {
14053               unsigned int insn2;
14054               bfd_vma offset = rel->r_offset;
14055
14056               if ((tls_mask & TLS_TPRELGD) != 0)
14057                 {
14058                   /* IE */
14059                   r_type = R_PPC64_NONE;
14060                   insn2 = 0x7c636a14;   /* add 3,3,13 */
14061                 }
14062               else
14063                 {
14064                   /* LE */
14065                   if (toc_symndx != 0)
14066                     {
14067                       r_symndx = toc_symndx;
14068                       rel->r_addend = toc_addend;
14069                     }
14070                   r_type = R_PPC64_TPREL16_LO;
14071                   rel->r_offset = offset + d_offset;
14072                   insn2 = 0x38630000;   /* addi 3,3,0 */
14073                 }
14074               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14075               /* Zap the reloc on the _tls_get_addr call too.  */
14076               BFD_ASSERT (offset == rel[1].r_offset);
14077               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14078               bfd_put_32 (input_bfd, insn2, contents + offset);
14079               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
14080                 goto again;
14081             }
14082           break;
14083
14084         case R_PPC64_TLSLD:
14085           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14086             {
14087               unsigned int insn2;
14088               bfd_vma offset = rel->r_offset;
14089
14090               if (toc_symndx)
14091                 sec = local_sections[toc_symndx];
14092               for (r_symndx = 0;
14093                    r_symndx < symtab_hdr->sh_info;
14094                    r_symndx++)
14095                 if (local_sections[r_symndx] == sec)
14096                   break;
14097               if (r_symndx >= symtab_hdr->sh_info)
14098                 r_symndx = STN_UNDEF;
14099               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14100               if (r_symndx != STN_UNDEF)
14101                 rel->r_addend -= (local_syms[r_symndx].st_value
14102                                   + sec->output_offset
14103                                   + sec->output_section->vma);
14104
14105               r_type = R_PPC64_TPREL16_LO;
14106               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14107               rel->r_offset = offset + d_offset;
14108               /* Zap the reloc on the _tls_get_addr call too.  */
14109               BFD_ASSERT (offset == rel[1].r_offset);
14110               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14111               insn2 = 0x38630000;       /* addi 3,3,0 */
14112               bfd_put_32 (input_bfd, insn2, contents + offset);
14113               goto again;
14114             }
14115           break;
14116
14117         case R_PPC64_DTPMOD64:
14118           if (rel + 1 < relend
14119               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14120               && rel[1].r_offset == rel->r_offset + 8)
14121             {
14122               if ((tls_mask & TLS_GD) == 0)
14123                 {
14124                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14125                   if ((tls_mask & TLS_TPRELGD) != 0)
14126                     r_type = R_PPC64_TPREL64;
14127                   else
14128                     {
14129                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14130                       r_type = R_PPC64_NONE;
14131                     }
14132                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14133                 }
14134             }
14135           else
14136             {
14137               if ((tls_mask & TLS_LD) == 0)
14138                 {
14139                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14140                   r_type = R_PPC64_NONE;
14141                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14142                 }
14143             }
14144           break;
14145
14146         case R_PPC64_TPREL64:
14147           if ((tls_mask & TLS_TPREL) == 0)
14148             {
14149               r_type = R_PPC64_NONE;
14150               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14151             }
14152           break;
14153
14154         case R_PPC64_ENTRY:
14155           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14156           if (!bfd_link_pic (info)
14157               && !info->traditional_format
14158               && relocation + 0x80008000 <= 0xffffffff)
14159             {
14160               unsigned int insn1, insn2;
14161
14162               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14163               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14164               if ((insn1 & ~0xfffc) == LD_R2_0R12
14165                   && insn2 == ADD_R2_R2_R12)
14166                 {
14167                   bfd_put_32 (input_bfd,
14168                               LIS_R2 + PPC_HA (relocation),
14169                               contents + rel->r_offset);
14170                   bfd_put_32 (input_bfd,
14171                               ADDI_R2_R2 + PPC_LO (relocation),
14172                               contents + rel->r_offset + 4);
14173                 }
14174             }
14175           else
14176             {
14177               relocation -= (rel->r_offset
14178                              + input_section->output_offset
14179                              + input_section->output_section->vma);
14180               if (relocation + 0x80008000 <= 0xffffffff)
14181                 {
14182                   unsigned int insn1, insn2;
14183
14184                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14185                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14186                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14187                       && insn2 == ADD_R2_R2_R12)
14188                     {
14189                       bfd_put_32 (input_bfd,
14190                                   ADDIS_R2_R12 + PPC_HA (relocation),
14191                                   contents + rel->r_offset);
14192                       bfd_put_32 (input_bfd,
14193                                   ADDI_R2_R2 + PPC_LO (relocation),
14194                                   contents + rel->r_offset + 4);
14195                     }
14196                 }
14197             }
14198           break;
14199
14200         case R_PPC64_REL16_HA:
14201           /* If we are generating a non-PIC executable, edit
14202              .  0:      addis 2,12,.TOC.-0b@ha
14203              .          addi 2,2,.TOC.-0b@l
14204              used by ELFv2 global entry points to set up r2, to
14205              .          lis 2,.TOC.@ha
14206              .          addi 2,2,.TOC.@l
14207              if .TOC. is in range.  */
14208           if (!bfd_link_pic (info)
14209               && !info->traditional_format
14210               && !htab->opd_abi
14211               && rel->r_addend == d_offset
14212               && h != NULL && &h->elf == htab->elf.hgot
14213               && rel + 1 < relend
14214               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14215               && rel[1].r_offset == rel->r_offset + 4
14216               && rel[1].r_addend == rel->r_addend + 4
14217               && relocation + 0x80008000 <= 0xffffffff)
14218             {
14219               unsigned int insn1, insn2;
14220               bfd_vma offset = rel->r_offset - d_offset;
14221               insn1 = bfd_get_32 (input_bfd, contents + offset);
14222               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14223               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14224                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14225                 {
14226                   r_type = R_PPC64_ADDR16_HA;
14227                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14228                   rel->r_addend -= d_offset;
14229                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14230                   rel[1].r_addend -= d_offset + 4;
14231                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14232                 }
14233             }
14234           break;
14235         }
14236
14237       /* Handle other relocations that tweak non-addend part of insn.  */
14238       insn = 0;
14239       max_br_offset = 1 << 25;
14240       addend = rel->r_addend;
14241       reloc_dest = DEST_NORMAL;
14242       switch (r_type)
14243         {
14244         default:
14245           break;
14246
14247         case R_PPC64_TOCSAVE:
14248           if (relocation + addend == (rel->r_offset
14249                                       + input_section->output_offset
14250                                       + input_section->output_section->vma)
14251               && tocsave_find (htab, NO_INSERT,
14252                                &local_syms, rel, input_bfd))
14253             {
14254               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14255               if (insn == NOP
14256                   || insn == CROR_151515 || insn == CROR_313131)
14257                 bfd_put_32 (input_bfd,
14258                             STD_R2_0R1 + STK_TOC (htab),
14259                             contents + rel->r_offset);
14260             }
14261           break;
14262
14263           /* Branch taken prediction relocations.  */
14264         case R_PPC64_ADDR14_BRTAKEN:
14265         case R_PPC64_REL14_BRTAKEN:
14266           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14267           /* Fall through.  */
14268
14269           /* Branch not taken prediction relocations.  */
14270         case R_PPC64_ADDR14_BRNTAKEN:
14271         case R_PPC64_REL14_BRNTAKEN:
14272           insn |= bfd_get_32 (input_bfd,
14273                               contents + rel->r_offset) & ~(0x01 << 21);
14274           /* Fall through.  */
14275
14276         case R_PPC64_REL14:
14277           max_br_offset = 1 << 15;
14278           /* Fall through.  */
14279
14280         case R_PPC64_REL24:
14281           /* Calls to functions with a different TOC, such as calls to
14282              shared objects, need to alter the TOC pointer.  This is
14283              done using a linkage stub.  A REL24 branching to these
14284              linkage stubs needs to be followed by a nop, as the nop
14285              will be replaced with an instruction to restore the TOC
14286              base pointer.  */
14287           fdh = h;
14288           if (h != NULL
14289               && h->oh != NULL
14290               && h->oh->is_func_descriptor)
14291             fdh = ppc_follow_link (h->oh);
14292           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14293                                            htab);
14294           if (stub_entry != NULL
14295               && (stub_entry->stub_type == ppc_stub_plt_call
14296                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14297                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14298                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14299             {
14300               bfd_boolean can_plt_call = FALSE;
14301
14302               if (stub_entry->stub_type == ppc_stub_plt_call
14303                   && !htab->opd_abi
14304                   && htab->params->plt_localentry0 != 0
14305                   && is_elfv2_localentry0 (&h->elf))
14306                 {
14307                   /* The function doesn't use or change r2.  */
14308                   can_plt_call = TRUE;
14309                 }
14310
14311               /* All of these stubs may modify r2, so there must be a
14312                  branch and link followed by a nop.  The nop is
14313                  replaced by an insn to restore r2.  */
14314               else if (rel->r_offset + 8 <= input_section->size)
14315                 {
14316                   unsigned long br;
14317
14318                   br = bfd_get_32 (input_bfd,
14319                                    contents + rel->r_offset);
14320                   if ((br & 1) != 0)
14321                     {
14322                       unsigned long nop;
14323
14324                       nop = bfd_get_32 (input_bfd,
14325                                         contents + rel->r_offset + 4);
14326                       if (nop == NOP
14327                           || nop == CROR_151515 || nop == CROR_313131)
14328                         {
14329                           if (h != NULL
14330                               && (h == htab->tls_get_addr_fd
14331                                   || h == htab->tls_get_addr)
14332                               && htab->params->tls_get_addr_opt)
14333                             {
14334                               /* Special stub used, leave nop alone.  */
14335                             }
14336                           else
14337                             bfd_put_32 (input_bfd,
14338                                         LD_R2_0R1 + STK_TOC (htab),
14339                                         contents + rel->r_offset + 4);
14340                           can_plt_call = TRUE;
14341                         }
14342                     }
14343                 }
14344
14345               if (!can_plt_call && h != NULL)
14346                 {
14347                   const char *name = h->elf.root.root.string;
14348
14349                   if (*name == '.')
14350                     ++name;
14351
14352                   if (strncmp (name, "__libc_start_main", 17) == 0
14353                       && (name[17] == 0 || name[17] == '@'))
14354                     {
14355                       /* Allow crt1 branch to go via a toc adjusting
14356                          stub.  Other calls that never return could do
14357                          the same, if we could detect such.  */
14358                       can_plt_call = TRUE;
14359                     }
14360                 }
14361
14362               if (!can_plt_call)
14363                 {
14364                   /* g++ as of 20130507 emits self-calls without a
14365                      following nop.  This is arguably wrong since we
14366                      have conflicting information.  On the one hand a
14367                      global symbol and on the other a local call
14368                      sequence, but don't error for this special case.
14369                      It isn't possible to cheaply verify we have
14370                      exactly such a call.  Allow all calls to the same
14371                      section.  */
14372                   asection *code_sec = sec;
14373
14374                   if (get_opd_info (sec) != NULL)
14375                     {
14376                       bfd_vma off = (relocation + addend
14377                                      - sec->output_section->vma
14378                                      - sec->output_offset);
14379
14380                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14381                     }
14382                   if (code_sec == input_section)
14383                     can_plt_call = TRUE;
14384                 }
14385
14386               if (!can_plt_call)
14387                 {
14388                   if (stub_entry->stub_type == ppc_stub_plt_call
14389                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14390                     info->callbacks->einfo
14391                       /* xgettext:c-format */
14392                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14393                          "recompile with -fPIC\n"),
14394                        input_bfd, input_section, rel->r_offset, sym_name);
14395                   else
14396                     info->callbacks->einfo
14397                       /* xgettext:c-format */
14398                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14399                          "(-mcmodel=small toc adjust stub)\n"),
14400                        input_bfd, input_section, rel->r_offset, sym_name);
14401
14402                   bfd_set_error (bfd_error_bad_value);
14403                   ret = FALSE;
14404                 }
14405
14406               if (can_plt_call
14407                   && (stub_entry->stub_type == ppc_stub_plt_call
14408                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14409                 unresolved_reloc = FALSE;
14410             }
14411
14412           if ((stub_entry == NULL
14413                || stub_entry->stub_type == ppc_stub_long_branch
14414                || stub_entry->stub_type == ppc_stub_plt_branch)
14415               && get_opd_info (sec) != NULL)
14416             {
14417               /* The branch destination is the value of the opd entry. */
14418               bfd_vma off = (relocation + addend
14419                              - sec->output_section->vma
14420                              - sec->output_offset);
14421               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14422               if (dest != (bfd_vma) -1)
14423                 {
14424                   relocation = dest;
14425                   addend = 0;
14426                   reloc_dest = DEST_OPD;
14427                 }
14428             }
14429
14430           /* If the branch is out of reach we ought to have a long
14431              branch stub.  */
14432           from = (rel->r_offset
14433                   + input_section->output_offset
14434                   + input_section->output_section->vma);
14435
14436           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14437                                                   ? fdh->elf.other
14438                                                   : sym->st_other);
14439
14440           if (stub_entry != NULL
14441               && (stub_entry->stub_type == ppc_stub_long_branch
14442                   || stub_entry->stub_type == ppc_stub_plt_branch)
14443               && (r_type == R_PPC64_ADDR14_BRTAKEN
14444                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14445                   || (relocation + addend - from + max_br_offset
14446                       < 2 * max_br_offset)))
14447             /* Don't use the stub if this branch is in range.  */
14448             stub_entry = NULL;
14449
14450           if (stub_entry != NULL)
14451             {
14452               /* Munge up the value and addend so that we call the stub
14453                  rather than the procedure directly.  */
14454               asection *stub_sec = stub_entry->group->stub_sec;
14455
14456               if (stub_entry->stub_type == ppc_stub_save_res)
14457                 relocation += (stub_sec->output_offset
14458                                + stub_sec->output_section->vma
14459                                + stub_sec->size - htab->sfpr->size
14460                                - htab->sfpr->output_offset
14461                                - htab->sfpr->output_section->vma);
14462               else
14463                 relocation = (stub_entry->stub_offset
14464                               + stub_sec->output_offset
14465                               + stub_sec->output_section->vma);
14466               addend = 0;
14467               reloc_dest = DEST_STUB;
14468
14469               if ((stub_entry->stub_type == ppc_stub_plt_call
14470                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14471                   && (ALWAYS_EMIT_R2SAVE
14472                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14473                   && rel + 1 < relend
14474                   && rel[1].r_offset == rel->r_offset + 4
14475                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14476                 relocation += 4;
14477             }
14478
14479           if (insn != 0)
14480             {
14481               if (is_isa_v2)
14482                 {
14483                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14484                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14485                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14486                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14487                     insn |= 0x02 << 21;
14488                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14489                     insn |= 0x08 << 21;
14490                   else
14491                     break;
14492                 }
14493               else
14494                 {
14495                   /* Invert 'y' bit if not the default.  */
14496                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14497                     insn ^= 0x01 << 21;
14498                 }
14499
14500               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14501             }
14502
14503           /* NOP out calls to undefined weak functions.
14504              We can thus call a weak function without first
14505              checking whether the function is defined.  */
14506           else if (h != NULL
14507                    && h->elf.root.type == bfd_link_hash_undefweak
14508                    && h->elf.dynindx == -1
14509                    && r_type == R_PPC64_REL24
14510                    && relocation == 0
14511                    && addend == 0)
14512             {
14513               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14514               goto copy_reloc;
14515             }
14516           break;
14517         }
14518
14519       /* Set `addend'.  */
14520       tls_type = 0;
14521       switch (r_type)
14522         {
14523         default:
14524           info->callbacks->einfo
14525             /* xgettext:c-format */
14526             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14527              input_bfd, (int) r_type, sym_name);
14528
14529           bfd_set_error (bfd_error_bad_value);
14530           ret = FALSE;
14531           goto copy_reloc;
14532
14533         case R_PPC64_NONE:
14534         case R_PPC64_TLS:
14535         case R_PPC64_TLSGD:
14536         case R_PPC64_TLSLD:
14537         case R_PPC64_TOCSAVE:
14538         case R_PPC64_GNU_VTINHERIT:
14539         case R_PPC64_GNU_VTENTRY:
14540         case R_PPC64_ENTRY:
14541           goto copy_reloc;
14542
14543           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14544              address in the GOT as relocation value instead of the
14545              symbol's value itself.  Also, create a GOT entry for the
14546              symbol and put the symbol value there.  */
14547         case R_PPC64_GOT_TLSGD16:
14548         case R_PPC64_GOT_TLSGD16_LO:
14549         case R_PPC64_GOT_TLSGD16_HI:
14550         case R_PPC64_GOT_TLSGD16_HA:
14551           tls_type = TLS_TLS | TLS_GD;
14552           goto dogot;
14553
14554         case R_PPC64_GOT_TLSLD16:
14555         case R_PPC64_GOT_TLSLD16_LO:
14556         case R_PPC64_GOT_TLSLD16_HI:
14557         case R_PPC64_GOT_TLSLD16_HA:
14558           tls_type = TLS_TLS | TLS_LD;
14559           goto dogot;
14560
14561         case R_PPC64_GOT_TPREL16_DS:
14562         case R_PPC64_GOT_TPREL16_LO_DS:
14563         case R_PPC64_GOT_TPREL16_HI:
14564         case R_PPC64_GOT_TPREL16_HA:
14565           tls_type = TLS_TLS | TLS_TPREL;
14566           goto dogot;
14567
14568         case R_PPC64_GOT_DTPREL16_DS:
14569         case R_PPC64_GOT_DTPREL16_LO_DS:
14570         case R_PPC64_GOT_DTPREL16_HI:
14571         case R_PPC64_GOT_DTPREL16_HA:
14572           tls_type = TLS_TLS | TLS_DTPREL;
14573           goto dogot;
14574
14575         case R_PPC64_GOT16:
14576         case R_PPC64_GOT16_LO:
14577         case R_PPC64_GOT16_HI:
14578         case R_PPC64_GOT16_HA:
14579         case R_PPC64_GOT16_DS:
14580         case R_PPC64_GOT16_LO_DS:
14581         dogot:
14582           {
14583             /* Relocation is to the entry for this symbol in the global
14584                offset table.  */
14585             asection *got;
14586             bfd_vma *offp;
14587             bfd_vma off;
14588             unsigned long indx = 0;
14589             struct got_entry *ent;
14590
14591             if (tls_type == (TLS_TLS | TLS_LD)
14592                 && (h == NULL
14593                     || !h->elf.def_dynamic))
14594               ent = ppc64_tlsld_got (input_bfd);
14595             else
14596               {
14597                 if (h != NULL)
14598                   {
14599                     if (!htab->elf.dynamic_sections_created
14600                         || h->elf.dynindx == -1
14601                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14602                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14603                       /* This is actually a static link, or it is a
14604                          -Bsymbolic link and the symbol is defined
14605                          locally, or the symbol was forced to be local
14606                          because of a version file.  */
14607                       ;
14608                     else
14609                       {
14610                         indx = h->elf.dynindx;
14611                         unresolved_reloc = FALSE;
14612                       }
14613                     ent = h->elf.got.glist;
14614                   }
14615                 else
14616                   {
14617                     if (local_got_ents == NULL)
14618                       abort ();
14619                     ent = local_got_ents[r_symndx];
14620                   }
14621
14622                 for (; ent != NULL; ent = ent->next)
14623                   if (ent->addend == orig_rel.r_addend
14624                       && ent->owner == input_bfd
14625                       && ent->tls_type == tls_type)
14626                     break;
14627               }
14628
14629             if (ent == NULL)
14630               abort ();
14631             if (ent->is_indirect)
14632               ent = ent->got.ent;
14633             offp = &ent->got.offset;
14634             got = ppc64_elf_tdata (ent->owner)->got;
14635             if (got == NULL)
14636               abort ();
14637
14638             /* The offset must always be a multiple of 8.  We use the
14639                least significant bit to record whether we have already
14640                processed this entry.  */
14641             off = *offp;
14642             if ((off & 1) != 0)
14643               off &= ~1;
14644             else
14645               {
14646                 /* Generate relocs for the dynamic linker, except in
14647                    the case of TLSLD where we'll use one entry per
14648                    module.  */
14649                 asection *relgot;
14650                 bfd_boolean ifunc;
14651
14652                 *offp = off | 1;
14653                 relgot = NULL;
14654                 ifunc = (h != NULL
14655                          ? h->elf.type == STT_GNU_IFUNC
14656                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14657                 if (ifunc)
14658                   {
14659                     relgot = htab->elf.irelplt;
14660                     if (indx == 0)
14661                       htab->local_ifunc_resolver = 1;
14662                     else if (is_static_defined (&h->elf))
14663                       htab->maybe_local_ifunc_resolver = 1;
14664                   }
14665                 else if (indx != 0
14666                          || (bfd_link_pic (info)
14667                              && (h == NULL
14668                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14669                                  || (tls_type == (TLS_TLS | TLS_LD)
14670                                      && !h->elf.def_dynamic))))
14671                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14672                 if (relgot != NULL)
14673                   {
14674                     outrel.r_offset = (got->output_section->vma
14675                                        + got->output_offset
14676                                        + off);
14677                     outrel.r_addend = addend;
14678                     if (tls_type & (TLS_LD | TLS_GD))
14679                       {
14680                         outrel.r_addend = 0;
14681                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14682                         if (tls_type == (TLS_TLS | TLS_GD))
14683                           {
14684                             loc = relgot->contents;
14685                             loc += (relgot->reloc_count++
14686                                     * sizeof (Elf64_External_Rela));
14687                             bfd_elf64_swap_reloca_out (output_bfd,
14688                                                        &outrel, loc);
14689                             outrel.r_offset += 8;
14690                             outrel.r_addend = addend;
14691                             outrel.r_info
14692                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14693                           }
14694                       }
14695                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14696                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14697                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14698                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14699                     else if (indx != 0)
14700                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14701                     else
14702                       {
14703                         if (ifunc)
14704                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14705                         else
14706                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14707
14708                         /* Write the .got section contents for the sake
14709                            of prelink.  */
14710                         loc = got->contents + off;
14711                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14712                                     loc);
14713                       }
14714
14715                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14716                       {
14717                         outrel.r_addend += relocation;
14718                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14719                           {
14720                             if (htab->elf.tls_sec == NULL)
14721                               outrel.r_addend = 0;
14722                             else
14723                               outrel.r_addend -= htab->elf.tls_sec->vma;
14724                           }
14725                       }
14726                     loc = relgot->contents;
14727                     loc += (relgot->reloc_count++
14728                             * sizeof (Elf64_External_Rela));
14729                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14730                   }
14731
14732                 /* Init the .got section contents here if we're not
14733                    emitting a reloc.  */
14734                 else
14735                   {
14736                     relocation += addend;
14737                     if (tls_type != 0)
14738                       {
14739                         if (htab->elf.tls_sec == NULL)
14740                           relocation = 0;
14741                         else
14742                           {
14743                             if (tls_type & TLS_LD)
14744                               relocation = 0;
14745                             else
14746                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14747                             if (tls_type & TLS_TPREL)
14748                               relocation += DTP_OFFSET - TP_OFFSET;
14749                           }
14750
14751                         if (tls_type & (TLS_GD | TLS_LD))
14752                           {
14753                             bfd_put_64 (output_bfd, relocation,
14754                                         got->contents + off + 8);
14755                             relocation = 1;
14756                           }
14757                       }
14758                     bfd_put_64 (output_bfd, relocation,
14759                                 got->contents + off);
14760                   }
14761               }
14762
14763             if (off >= (bfd_vma) -2)
14764               abort ();
14765
14766             relocation = got->output_section->vma + got->output_offset + off;
14767             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14768           }
14769           break;
14770
14771         case R_PPC64_PLT16_HA:
14772         case R_PPC64_PLT16_HI:
14773         case R_PPC64_PLT16_LO:
14774         case R_PPC64_PLT32:
14775         case R_PPC64_PLT64:
14776           /* Relocation is to the entry for this symbol in the
14777              procedure linkage table.  */
14778           {
14779             struct plt_entry **plt_list = NULL;
14780             if (h != NULL)
14781               plt_list = &h->elf.plt.plist;
14782             else if (local_got_ents != NULL)
14783               {
14784                 struct plt_entry **local_plt = (struct plt_entry **)
14785                   (local_got_ents + symtab_hdr->sh_info);
14786                 unsigned char *local_got_tls_masks = (unsigned char *)
14787                   (local_plt + symtab_hdr->sh_info);
14788                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14789                   plt_list = local_plt + r_symndx;
14790               }
14791             if (plt_list)
14792               {
14793                 struct plt_entry *ent;
14794
14795                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14796                   if (ent->plt.offset != (bfd_vma) -1
14797                       && ent->addend == orig_rel.r_addend)
14798                     {
14799                       asection *plt;
14800
14801                       plt = htab->elf.splt;
14802                       if (!htab->elf.dynamic_sections_created
14803                           || h == NULL
14804                           || h->elf.dynindx == -1)
14805                         plt = htab->elf.iplt;
14806                       relocation = (plt->output_section->vma
14807                                     + plt->output_offset
14808                                     + ent->plt.offset);
14809                       addend = 0;
14810                       unresolved_reloc = FALSE;
14811                       break;
14812                     }
14813               }
14814           }
14815           break;
14816
14817         case R_PPC64_TOC:
14818           /* Relocation value is TOC base.  */
14819           relocation = TOCstart;
14820           if (r_symndx == STN_UNDEF)
14821             relocation += htab->sec_info[input_section->id].toc_off;
14822           else if (unresolved_reloc)
14823             ;
14824           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14825             relocation += htab->sec_info[sec->id].toc_off;
14826           else
14827             unresolved_reloc = TRUE;
14828           goto dodyn;
14829
14830           /* TOC16 relocs.  We want the offset relative to the TOC base,
14831              which is the address of the start of the TOC plus 0x8000.
14832              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14833              in this order.  */
14834         case R_PPC64_TOC16:
14835         case R_PPC64_TOC16_LO:
14836         case R_PPC64_TOC16_HI:
14837         case R_PPC64_TOC16_DS:
14838         case R_PPC64_TOC16_LO_DS:
14839         case R_PPC64_TOC16_HA:
14840           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14841           break;
14842
14843           /* Relocate against the beginning of the section.  */
14844         case R_PPC64_SECTOFF:
14845         case R_PPC64_SECTOFF_LO:
14846         case R_PPC64_SECTOFF_HI:
14847         case R_PPC64_SECTOFF_DS:
14848         case R_PPC64_SECTOFF_LO_DS:
14849         case R_PPC64_SECTOFF_HA:
14850           if (sec != NULL)
14851             addend -= sec->output_section->vma;
14852           break;
14853
14854         case R_PPC64_REL16:
14855         case R_PPC64_REL16_LO:
14856         case R_PPC64_REL16_HI:
14857         case R_PPC64_REL16_HA:
14858         case R_PPC64_REL16DX_HA:
14859           break;
14860
14861         case R_PPC64_REL14:
14862         case R_PPC64_REL14_BRNTAKEN:
14863         case R_PPC64_REL14_BRTAKEN:
14864         case R_PPC64_REL24:
14865           break;
14866
14867         case R_PPC64_TPREL16:
14868         case R_PPC64_TPREL16_LO:
14869         case R_PPC64_TPREL16_HI:
14870         case R_PPC64_TPREL16_HA:
14871         case R_PPC64_TPREL16_DS:
14872         case R_PPC64_TPREL16_LO_DS:
14873         case R_PPC64_TPREL16_HIGH:
14874         case R_PPC64_TPREL16_HIGHA:
14875         case R_PPC64_TPREL16_HIGHER:
14876         case R_PPC64_TPREL16_HIGHERA:
14877         case R_PPC64_TPREL16_HIGHEST:
14878         case R_PPC64_TPREL16_HIGHESTA:
14879           if (h != NULL
14880               && h->elf.root.type == bfd_link_hash_undefweak
14881               && h->elf.dynindx == -1)
14882             {
14883               /* Make this relocation against an undefined weak symbol
14884                  resolve to zero.  This is really just a tweak, since
14885                  code using weak externs ought to check that they are
14886                  defined before using them.  */
14887               bfd_byte *p = contents + rel->r_offset - d_offset;
14888
14889               insn = bfd_get_32 (input_bfd, p);
14890               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14891               if (insn != 0)
14892                 bfd_put_32 (input_bfd, insn, p);
14893               break;
14894             }
14895           if (htab->elf.tls_sec != NULL)
14896             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14897           /* The TPREL16 relocs shouldn't really be used in shared
14898              libs or with non-local symbols as that will result in
14899              DT_TEXTREL being set, but support them anyway.  */
14900           goto dodyn;
14901
14902         case R_PPC64_DTPREL16:
14903         case R_PPC64_DTPREL16_LO:
14904         case R_PPC64_DTPREL16_HI:
14905         case R_PPC64_DTPREL16_HA:
14906         case R_PPC64_DTPREL16_DS:
14907         case R_PPC64_DTPREL16_LO_DS:
14908         case R_PPC64_DTPREL16_HIGH:
14909         case R_PPC64_DTPREL16_HIGHA:
14910         case R_PPC64_DTPREL16_HIGHER:
14911         case R_PPC64_DTPREL16_HIGHERA:
14912         case R_PPC64_DTPREL16_HIGHEST:
14913         case R_PPC64_DTPREL16_HIGHESTA:
14914           if (htab->elf.tls_sec != NULL)
14915             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14916           break;
14917
14918         case R_PPC64_ADDR64_LOCAL:
14919           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14920                                               ? h->elf.other
14921                                               : sym->st_other);
14922           break;
14923
14924         case R_PPC64_DTPMOD64:
14925           relocation = 1;
14926           addend = 0;
14927           goto dodyn;
14928
14929         case R_PPC64_TPREL64:
14930           if (htab->elf.tls_sec != NULL)
14931             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14932           goto dodyn;
14933
14934         case R_PPC64_DTPREL64:
14935           if (htab->elf.tls_sec != NULL)
14936             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14937           /* Fall through.  */
14938
14939           /* Relocations that may need to be propagated if this is a
14940              dynamic object.  */
14941         case R_PPC64_REL30:
14942         case R_PPC64_REL32:
14943         case R_PPC64_REL64:
14944         case R_PPC64_ADDR14:
14945         case R_PPC64_ADDR14_BRNTAKEN:
14946         case R_PPC64_ADDR14_BRTAKEN:
14947         case R_PPC64_ADDR16:
14948         case R_PPC64_ADDR16_DS:
14949         case R_PPC64_ADDR16_HA:
14950         case R_PPC64_ADDR16_HI:
14951         case R_PPC64_ADDR16_HIGH:
14952         case R_PPC64_ADDR16_HIGHA:
14953         case R_PPC64_ADDR16_HIGHER:
14954         case R_PPC64_ADDR16_HIGHERA:
14955         case R_PPC64_ADDR16_HIGHEST:
14956         case R_PPC64_ADDR16_HIGHESTA:
14957         case R_PPC64_ADDR16_LO:
14958         case R_PPC64_ADDR16_LO_DS:
14959         case R_PPC64_ADDR24:
14960         case R_PPC64_ADDR32:
14961         case R_PPC64_ADDR64:
14962         case R_PPC64_UADDR16:
14963         case R_PPC64_UADDR32:
14964         case R_PPC64_UADDR64:
14965         dodyn:
14966           if ((input_section->flags & SEC_ALLOC) == 0)
14967             break;
14968
14969           if (NO_OPD_RELOCS && is_opd)
14970             break;
14971
14972           if (bfd_link_pic (info)
14973               ? ((h == NULL
14974                   || h->dyn_relocs != NULL)
14975                  && ((h != NULL && pc_dynrelocs (h))
14976                      || must_be_dyn_reloc (info, r_type)))
14977               : (h != NULL
14978                  ? h->dyn_relocs != NULL
14979                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14980             {
14981               bfd_boolean skip, relocate;
14982               asection *sreloc;
14983               bfd_vma out_off;
14984               long indx = 0;
14985
14986               /* When generating a dynamic object, these relocations
14987                  are copied into the output file to be resolved at run
14988                  time.  */
14989
14990               skip = FALSE;
14991               relocate = FALSE;
14992
14993               out_off = _bfd_elf_section_offset (output_bfd, info,
14994                                                  input_section, rel->r_offset);
14995               if (out_off == (bfd_vma) -1)
14996                 skip = TRUE;
14997               else if (out_off == (bfd_vma) -2)
14998                 skip = TRUE, relocate = TRUE;
14999               out_off += (input_section->output_section->vma
15000                           + input_section->output_offset);
15001               outrel.r_offset = out_off;
15002               outrel.r_addend = rel->r_addend;
15003
15004               /* Optimize unaligned reloc use.  */
15005               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
15006                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
15007                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15008               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15009                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15010                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15011               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15012                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15013                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15014
15015               if (skip)
15016                 memset (&outrel, 0, sizeof outrel);
15017               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15018                        && !is_opd
15019                        && r_type != R_PPC64_TOC)
15020                 {
15021                   indx = h->elf.dynindx;
15022                   BFD_ASSERT (indx != -1);
15023                   outrel.r_info = ELF64_R_INFO (indx, r_type);
15024                 }
15025               else
15026                 {
15027                   /* This symbol is local, or marked to become local,
15028                      or this is an opd section reloc which must point
15029                      at a local function.  */
15030                   outrel.r_addend += relocation;
15031                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
15032                     {
15033                       if (is_opd && h != NULL)
15034                         {
15035                           /* Lie about opd entries.  This case occurs
15036                              when building shared libraries and we
15037                              reference a function in another shared
15038                              lib.  The same thing happens for a weak
15039                              definition in an application that's
15040                              overridden by a strong definition in a
15041                              shared lib.  (I believe this is a generic
15042                              bug in binutils handling of weak syms.)
15043                              In these cases we won't use the opd
15044                              entry in this lib.  */
15045                           unresolved_reloc = FALSE;
15046                         }
15047                       if (!is_opd
15048                           && r_type == R_PPC64_ADDR64
15049                           && (h != NULL
15050                               ? h->elf.type == STT_GNU_IFUNC
15051                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15052                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15053                       else
15054                         {
15055                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15056
15057                           /* We need to relocate .opd contents for ld.so.
15058                              Prelink also wants simple and consistent rules
15059                              for relocs.  This make all RELATIVE relocs have
15060                              *r_offset equal to r_addend.  */
15061                           relocate = TRUE;
15062                         }
15063                     }
15064                   else
15065                     {
15066                       if (h != NULL
15067                           ? h->elf.type == STT_GNU_IFUNC
15068                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15069                         {
15070                           info->callbacks->einfo
15071                             /* xgettext:c-format */
15072                             (_("%H: %s for indirect "
15073                                "function `%T' unsupported\n"),
15074                              input_bfd, input_section, rel->r_offset,
15075                              ppc64_elf_howto_table[r_type]->name,
15076                              sym_name);
15077                           ret = FALSE;
15078                         }
15079                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
15080                         ;
15081                       else if (sec == NULL || sec->owner == NULL)
15082                         {
15083                           bfd_set_error (bfd_error_bad_value);
15084                           return FALSE;
15085                         }
15086                       else
15087                         {
15088                           asection *osec;
15089
15090                           osec = sec->output_section;
15091                           indx = elf_section_data (osec)->dynindx;
15092
15093                           if (indx == 0)
15094                             {
15095                               if ((osec->flags & SEC_READONLY) == 0
15096                                   && htab->elf.data_index_section != NULL)
15097                                 osec = htab->elf.data_index_section;
15098                               else
15099                                 osec = htab->elf.text_index_section;
15100                               indx = elf_section_data (osec)->dynindx;
15101                             }
15102                           BFD_ASSERT (indx != 0);
15103
15104                           /* We are turning this relocation into one
15105                              against a section symbol, so subtract out
15106                              the output section's address but not the
15107                              offset of the input section in the output
15108                              section.  */
15109                           outrel.r_addend -= osec->vma;
15110                         }
15111
15112                       outrel.r_info = ELF64_R_INFO (indx, r_type);
15113                     }
15114                 }
15115
15116               sreloc = elf_section_data (input_section)->sreloc;
15117               if (h != NULL
15118                   ? h->elf.type == STT_GNU_IFUNC
15119                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15120                 {
15121                   sreloc = htab->elf.irelplt;
15122                   if (indx == 0)
15123                     htab->local_ifunc_resolver = 1;
15124                   else if (is_static_defined (&h->elf))
15125                     htab->maybe_local_ifunc_resolver = 1;
15126                 }
15127               if (sreloc == NULL)
15128                 abort ();
15129
15130               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15131                   >= sreloc->size)
15132                 abort ();
15133               loc = sreloc->contents;
15134               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15135               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15136
15137               /* If this reloc is against an external symbol, it will
15138                  be computed at runtime, so there's no need to do
15139                  anything now.  However, for the sake of prelink ensure
15140                  that the section contents are a known value.  */
15141               if (! relocate)
15142                 {
15143                   unresolved_reloc = FALSE;
15144                   /* The value chosen here is quite arbitrary as ld.so
15145                      ignores section contents except for the special
15146                      case of .opd where the contents might be accessed
15147                      before relocation.  Choose zero, as that won't
15148                      cause reloc overflow.  */
15149                   relocation = 0;
15150                   addend = 0;
15151                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15152                      to improve backward compatibility with older
15153                      versions of ld.  */
15154                   if (r_type == R_PPC64_ADDR64)
15155                     addend = outrel.r_addend;
15156                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15157                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15158                     addend = outrel.r_offset;
15159                 }
15160             }
15161           break;
15162
15163         case R_PPC64_COPY:
15164         case R_PPC64_GLOB_DAT:
15165         case R_PPC64_JMP_SLOT:
15166         case R_PPC64_JMP_IREL:
15167         case R_PPC64_RELATIVE:
15168           /* We shouldn't ever see these dynamic relocs in relocatable
15169              files.  */
15170           /* Fall through.  */
15171
15172         case R_PPC64_PLTGOT16:
15173         case R_PPC64_PLTGOT16_DS:
15174         case R_PPC64_PLTGOT16_HA:
15175         case R_PPC64_PLTGOT16_HI:
15176         case R_PPC64_PLTGOT16_LO:
15177         case R_PPC64_PLTGOT16_LO_DS:
15178         case R_PPC64_PLTREL32:
15179         case R_PPC64_PLTREL64:
15180           /* These ones haven't been implemented yet.  */
15181
15182           info->callbacks->einfo
15183             /* xgettext:c-format */
15184             (_("%P: %B: %s is not supported for `%T'\n"),
15185              input_bfd,
15186              ppc64_elf_howto_table[r_type]->name, sym_name);
15187
15188           bfd_set_error (bfd_error_invalid_operation);
15189           ret = FALSE;
15190           goto copy_reloc;
15191         }
15192
15193       /* Multi-instruction sequences that access the TOC can be
15194          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15195          to             nop;           addi rb,r2,x;  */
15196       howto = ppc64_elf_howto_table[(int) r_type];
15197       switch (r_type)
15198         {
15199         default:
15200           break;
15201
15202         case R_PPC64_GOT_TLSLD16_HI:
15203         case R_PPC64_GOT_TLSGD16_HI:
15204         case R_PPC64_GOT_TPREL16_HI:
15205         case R_PPC64_GOT_DTPREL16_HI:
15206         case R_PPC64_GOT16_HI:
15207         case R_PPC64_TOC16_HI:
15208           /* These relocs would only be useful if building up an
15209              offset to later add to r2, perhaps in an indexed
15210              addressing mode instruction.  Don't try to optimize.
15211              Unfortunately, the possibility of someone building up an
15212              offset like this or even with the HA relocs, means that
15213              we need to check the high insn when optimizing the low
15214              insn.  */
15215           break;
15216
15217         case R_PPC64_GOT_TLSLD16_HA:
15218         case R_PPC64_GOT_TLSGD16_HA:
15219         case R_PPC64_GOT_TPREL16_HA:
15220         case R_PPC64_GOT_DTPREL16_HA:
15221         case R_PPC64_GOT16_HA:
15222         case R_PPC64_TOC16_HA:
15223           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15224               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15225             {
15226               bfd_byte *p = contents + (rel->r_offset & ~3);
15227               bfd_put_32 (input_bfd, NOP, p);
15228             }
15229           break;
15230
15231         case R_PPC64_GOT_TLSLD16_LO:
15232         case R_PPC64_GOT_TLSGD16_LO:
15233         case R_PPC64_GOT_TPREL16_LO_DS:
15234         case R_PPC64_GOT_DTPREL16_LO_DS:
15235         case R_PPC64_GOT16_LO:
15236         case R_PPC64_GOT16_LO_DS:
15237         case R_PPC64_TOC16_LO:
15238         case R_PPC64_TOC16_LO_DS:
15239           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15240               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15241             {
15242               bfd_byte *p = contents + (rel->r_offset & ~3);
15243               insn = bfd_get_32 (input_bfd, p);
15244               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15245                 {
15246                   /* Transform addic to addi when we change reg.  */
15247                   insn &= ~((0x3f << 26) | (0x1f << 16));
15248                   insn |= (14u << 26) | (2 << 16);
15249                 }
15250               else
15251                 {
15252                   insn &= ~(0x1f << 16);
15253                   insn |= 2 << 16;
15254                 }
15255               bfd_put_32 (input_bfd, insn, p);
15256             }
15257           break;
15258
15259         case R_PPC64_TPREL16_HA:
15260           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15261             {
15262               bfd_byte *p = contents + (rel->r_offset & ~3);
15263               insn = bfd_get_32 (input_bfd, p);
15264               if ((insn & ((0x3f << 26) | 0x1f << 16))
15265                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15266                 /* xgettext:c-format */
15267                 info->callbacks->minfo
15268                   (_("%H: warning: %s unexpected insn %#x.\n"),
15269                    input_bfd, input_section, rel->r_offset, howto->name, insn);
15270               else
15271                 bfd_put_32 (input_bfd, NOP, p);
15272             }
15273           break;
15274
15275         case R_PPC64_TPREL16_LO:
15276         case R_PPC64_TPREL16_LO_DS:
15277           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15278             {
15279               bfd_byte *p = contents + (rel->r_offset & ~3);
15280               insn = bfd_get_32 (input_bfd, p);
15281               insn &= ~(0x1f << 16);
15282               insn |= 13 << 16;
15283               bfd_put_32 (input_bfd, insn, p);
15284             }
15285           break;
15286         }
15287
15288       /* Do any further special processing.  */
15289       switch (r_type)
15290         {
15291         default:
15292           break;
15293
15294         case R_PPC64_REL16_HA:
15295         case R_PPC64_REL16DX_HA:
15296         case R_PPC64_ADDR16_HA:
15297         case R_PPC64_ADDR16_HIGHA:
15298         case R_PPC64_ADDR16_HIGHERA:
15299         case R_PPC64_ADDR16_HIGHESTA:
15300         case R_PPC64_TOC16_HA:
15301         case R_PPC64_SECTOFF_HA:
15302         case R_PPC64_TPREL16_HA:
15303         case R_PPC64_TPREL16_HIGHA:
15304         case R_PPC64_TPREL16_HIGHERA:
15305         case R_PPC64_TPREL16_HIGHESTA:
15306         case R_PPC64_DTPREL16_HA:
15307         case R_PPC64_DTPREL16_HIGHA:
15308         case R_PPC64_DTPREL16_HIGHERA:
15309         case R_PPC64_DTPREL16_HIGHESTA:
15310           /* It's just possible that this symbol is a weak symbol
15311              that's not actually defined anywhere. In that case,
15312              'sec' would be NULL, and we should leave the symbol
15313              alone (it will be set to zero elsewhere in the link).  */
15314           if (sec == NULL)
15315             break;
15316           /* Fall through.  */
15317
15318         case R_PPC64_GOT16_HA:
15319         case R_PPC64_PLTGOT16_HA:
15320         case R_PPC64_PLT16_HA:
15321         case R_PPC64_GOT_TLSGD16_HA:
15322         case R_PPC64_GOT_TLSLD16_HA:
15323         case R_PPC64_GOT_TPREL16_HA:
15324         case R_PPC64_GOT_DTPREL16_HA:
15325           /* Add 0x10000 if sign bit in 0:15 is set.
15326              Bits 0:15 are not used.  */
15327           addend += 0x8000;
15328           break;
15329
15330         case R_PPC64_ADDR16_DS:
15331         case R_PPC64_ADDR16_LO_DS:
15332         case R_PPC64_GOT16_DS:
15333         case R_PPC64_GOT16_LO_DS:
15334         case R_PPC64_PLT16_LO_DS:
15335         case R_PPC64_SECTOFF_DS:
15336         case R_PPC64_SECTOFF_LO_DS:
15337         case R_PPC64_TOC16_DS:
15338         case R_PPC64_TOC16_LO_DS:
15339         case R_PPC64_PLTGOT16_DS:
15340         case R_PPC64_PLTGOT16_LO_DS:
15341         case R_PPC64_GOT_TPREL16_DS:
15342         case R_PPC64_GOT_TPREL16_LO_DS:
15343         case R_PPC64_GOT_DTPREL16_DS:
15344         case R_PPC64_GOT_DTPREL16_LO_DS:
15345         case R_PPC64_TPREL16_DS:
15346         case R_PPC64_TPREL16_LO_DS:
15347         case R_PPC64_DTPREL16_DS:
15348         case R_PPC64_DTPREL16_LO_DS:
15349           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15350           mask = 3;
15351           /* If this reloc is against an lq, lxv, or stxv insn, then
15352              the value must be a multiple of 16.  This is somewhat of
15353              a hack, but the "correct" way to do this by defining _DQ
15354              forms of all the _DS relocs bloats all reloc switches in
15355              this file.  It doesn't make much sense to use these
15356              relocs in data, so testing the insn should be safe.  */
15357           if ((insn & (0x3f << 26)) == (56u << 26)
15358               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15359             mask = 15;
15360           relocation += addend;
15361           addend = insn & (mask ^ 3);
15362           if ((relocation & mask) != 0)
15363             {
15364               relocation ^= relocation & mask;
15365               info->callbacks->einfo
15366                 /* xgettext:c-format */
15367                 (_("%H: error: %s not a multiple of %u\n"),
15368                  input_bfd, input_section, rel->r_offset,
15369                  howto->name,
15370                  mask + 1);
15371               bfd_set_error (bfd_error_bad_value);
15372               ret = FALSE;
15373               goto copy_reloc;
15374             }
15375           break;
15376         }
15377
15378       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15379          because such sections are not SEC_ALLOC and thus ld.so will
15380          not process them.  */
15381       if (unresolved_reloc
15382           && !((input_section->flags & SEC_DEBUGGING) != 0
15383                && h->elf.def_dynamic)
15384           && _bfd_elf_section_offset (output_bfd, info, input_section,
15385                                       rel->r_offset) != (bfd_vma) -1)
15386         {
15387           info->callbacks->einfo
15388             /* xgettext:c-format */
15389             (_("%H: unresolvable %s against `%T'\n"),
15390              input_bfd, input_section, rel->r_offset,
15391              howto->name,
15392              h->elf.root.root.string);
15393           ret = FALSE;
15394         }
15395
15396       /* 16-bit fields in insns mostly have signed values, but a
15397          few insns have 16-bit unsigned values.  Really, we should
15398          have different reloc types.  */
15399       if (howto->complain_on_overflow != complain_overflow_dont
15400           && howto->dst_mask == 0xffff
15401           && (input_section->flags & SEC_CODE) != 0)
15402         {
15403           enum complain_overflow complain = complain_overflow_signed;
15404
15405           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15406           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15407             complain = complain_overflow_bitfield;
15408           else if (howto->rightshift == 0
15409                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15410                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15411                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15412                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15413                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15414                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15415             complain = complain_overflow_unsigned;
15416           if (howto->complain_on_overflow != complain)
15417             {
15418               alt_howto = *howto;
15419               alt_howto.complain_on_overflow = complain;
15420               howto = &alt_howto;
15421             }
15422         }
15423
15424       if (r_type == R_PPC64_REL16DX_HA)
15425         {
15426           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15427           if (rel->r_offset + 4 > input_section->size)
15428             r = bfd_reloc_outofrange;
15429           else
15430             {
15431               relocation += addend;
15432               relocation -= (rel->r_offset
15433                              + input_section->output_offset
15434                              + input_section->output_section->vma);
15435               relocation = (bfd_signed_vma) relocation >> 16;
15436               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15437               insn &= ~0x1fffc1;
15438               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15439               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15440               r = bfd_reloc_ok;
15441               if (relocation + 0x8000 > 0xffff)
15442                 r = bfd_reloc_overflow;
15443             }
15444         }
15445       else
15446         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15447                                       rel->r_offset, relocation, addend);
15448
15449       if (r != bfd_reloc_ok)
15450         {
15451           char *more_info = NULL;
15452           const char *reloc_name = howto->name;
15453
15454           if (reloc_dest != DEST_NORMAL)
15455             {
15456               more_info = bfd_malloc (strlen (reloc_name) + 8);
15457               if (more_info != NULL)
15458                 {
15459                   strcpy (more_info, reloc_name);
15460                   strcat (more_info, (reloc_dest == DEST_OPD
15461                                       ? " (OPD)" : " (stub)"));
15462                   reloc_name = more_info;
15463                 }
15464             }
15465
15466           if (r == bfd_reloc_overflow)
15467             {
15468               /* On code like "if (foo) foo();" don't report overflow
15469                  on a branch to zero when foo is undefined.  */
15470               if (!warned
15471                   && (reloc_dest == DEST_STUB
15472                       || !(h != NULL
15473                            && (h->elf.root.type == bfd_link_hash_undefweak
15474                                || h->elf.root.type == bfd_link_hash_undefined)
15475                            && is_branch_reloc (r_type))))
15476                 info->callbacks->reloc_overflow (info, &h->elf.root,
15477                                                  sym_name, reloc_name,
15478                                                  orig_rel.r_addend,
15479                                                  input_bfd, input_section,
15480                                                  rel->r_offset);
15481             }
15482           else
15483             {
15484               info->callbacks->einfo
15485                 /* xgettext:c-format */
15486                 (_("%H: %s against `%T': error %d\n"),
15487                  input_bfd, input_section, rel->r_offset,
15488                  reloc_name, sym_name, (int) r);
15489               ret = FALSE;
15490             }
15491           if (more_info != NULL)
15492             free (more_info);
15493         }
15494     copy_reloc:
15495       if (wrel != rel)
15496         *wrel = *rel;
15497     }
15498
15499   if (wrel != rel)
15500     {
15501       Elf_Internal_Shdr *rel_hdr;
15502       size_t deleted = rel - wrel;
15503
15504       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15505       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15506       if (rel_hdr->sh_size == 0)
15507         {
15508           /* It is too late to remove an empty reloc section.  Leave
15509              one NONE reloc.
15510              ??? What is wrong with an empty section???  */
15511           rel_hdr->sh_size = rel_hdr->sh_entsize;
15512           deleted -= 1;
15513         }
15514       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15515       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15516       input_section->reloc_count -= deleted;
15517     }
15518
15519   /* If we're emitting relocations, then shortly after this function
15520      returns, reloc offsets and addends for this section will be
15521      adjusted.  Worse, reloc symbol indices will be for the output
15522      file rather than the input.  Save a copy of the relocs for
15523      opd_entry_value.  */
15524   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15525     {
15526       bfd_size_type amt;
15527       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15528       rel = bfd_alloc (input_bfd, amt);
15529       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15530       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15531       if (rel == NULL)
15532         return FALSE;
15533       memcpy (rel, relocs, amt);
15534     }
15535   return ret;
15536 }
15537
15538 /* Adjust the value of any local symbols in opd sections.  */
15539
15540 static int
15541 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15542                               const char *name ATTRIBUTE_UNUSED,
15543                               Elf_Internal_Sym *elfsym,
15544                               asection *input_sec,
15545                               struct elf_link_hash_entry *h)
15546 {
15547   struct _opd_sec_data *opd;
15548   long adjust;
15549   bfd_vma value;
15550
15551   if (h != NULL)
15552     return 1;
15553
15554   opd = get_opd_info (input_sec);
15555   if (opd == NULL || opd->adjust == NULL)
15556     return 1;
15557
15558   value = elfsym->st_value - input_sec->output_offset;
15559   if (!bfd_link_relocatable (info))
15560     value -= input_sec->output_section->vma;
15561
15562   adjust = opd->adjust[OPD_NDX (value)];
15563   if (adjust == -1)
15564     return 2;
15565
15566   elfsym->st_value += adjust;
15567   return 1;
15568 }
15569
15570 /* Finish up dynamic symbol handling.  We set the contents of various
15571    dynamic sections here.  */
15572
15573 static bfd_boolean
15574 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15575                                  struct bfd_link_info *info,
15576                                  struct elf_link_hash_entry *h,
15577                                  Elf_Internal_Sym *sym)
15578 {
15579   struct ppc_link_hash_table *htab;
15580   struct plt_entry *ent;
15581   Elf_Internal_Rela rela;
15582   bfd_byte *loc;
15583
15584   htab = ppc_hash_table (info);
15585   if (htab == NULL)
15586     return FALSE;
15587
15588   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15589     if (ent->plt.offset != (bfd_vma) -1)
15590       {
15591         /* This symbol has an entry in the procedure linkage
15592            table.  Set it up.  */
15593         if (!htab->elf.dynamic_sections_created
15594             || h->dynindx == -1)
15595           {
15596             BFD_ASSERT (h->type == STT_GNU_IFUNC
15597                         && h->def_regular
15598                         && (h->root.type == bfd_link_hash_defined
15599                             || h->root.type == bfd_link_hash_defweak));
15600             rela.r_offset = (htab->elf.iplt->output_section->vma
15601                              + htab->elf.iplt->output_offset
15602                              + ent->plt.offset);
15603             if (htab->opd_abi)
15604               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15605             else
15606               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15607             rela.r_addend = (h->root.u.def.value
15608                              + h->root.u.def.section->output_offset
15609                              + h->root.u.def.section->output_section->vma
15610                              + ent->addend);
15611             loc = (htab->elf.irelplt->contents
15612                    + (htab->elf.irelplt->reloc_count++
15613                       * sizeof (Elf64_External_Rela)));
15614             htab->local_ifunc_resolver = 1;
15615           }
15616         else
15617           {
15618             rela.r_offset = (htab->elf.splt->output_section->vma
15619                              + htab->elf.splt->output_offset
15620                              + ent->plt.offset);
15621             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15622             rela.r_addend = ent->addend;
15623             loc = (htab->elf.srelplt->contents
15624                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15625                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15626             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15627               htab->maybe_local_ifunc_resolver = 1;
15628           }
15629         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15630
15631         if (!htab->opd_abi)
15632           {
15633             if (!h->def_regular)
15634               {
15635                 /* Mark the symbol as undefined, rather than as
15636                    defined in glink.  Leave the value if there were
15637                    any relocations where pointer equality matters
15638                    (this is a clue for the dynamic linker, to make
15639                    function pointer comparisons work between an
15640                    application and shared library), otherwise set it
15641                    to zero.  */
15642                 sym->st_shndx = SHN_UNDEF;
15643                 if (!h->pointer_equality_needed)
15644                   sym->st_value = 0;
15645                 else if (!h->ref_regular_nonweak)
15646                   {
15647                     /* This breaks function pointer comparisons, but
15648                        that is better than breaking tests for a NULL
15649                        function pointer.  */
15650                     sym->st_value = 0;
15651                   }
15652               }
15653           }
15654       }
15655
15656   if (h->needs_copy)
15657     {
15658       /* This symbol needs a copy reloc.  Set it up.  */
15659       asection *srel;
15660
15661       if (h->dynindx == -1
15662           || (h->root.type != bfd_link_hash_defined
15663               && h->root.type != bfd_link_hash_defweak)
15664           || htab->elf.srelbss == NULL
15665           || htab->elf.sreldynrelro == NULL)
15666         abort ();
15667
15668       rela.r_offset = (h->root.u.def.value
15669                        + h->root.u.def.section->output_section->vma
15670                        + h->root.u.def.section->output_offset);
15671       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15672       rela.r_addend = 0;
15673       if (h->root.u.def.section == htab->elf.sdynrelro)
15674         srel = htab->elf.sreldynrelro;
15675       else
15676         srel = htab->elf.srelbss;
15677       loc = srel->contents;
15678       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15679       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15680     }
15681
15682   return TRUE;
15683 }
15684
15685 /* Used to decide how to sort relocs in an optimal manner for the
15686    dynamic linker, before writing them out.  */
15687
15688 static enum elf_reloc_type_class
15689 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15690                             const asection *rel_sec,
15691                             const Elf_Internal_Rela *rela)
15692 {
15693   enum elf_ppc64_reloc_type r_type;
15694   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15695
15696   if (rel_sec == htab->elf.irelplt)
15697     return reloc_class_ifunc;
15698
15699   r_type = ELF64_R_TYPE (rela->r_info);
15700   switch (r_type)
15701     {
15702     case R_PPC64_RELATIVE:
15703       return reloc_class_relative;
15704     case R_PPC64_JMP_SLOT:
15705       return reloc_class_plt;
15706     case R_PPC64_COPY:
15707       return reloc_class_copy;
15708     default:
15709       return reloc_class_normal;
15710     }
15711 }
15712
15713 /* Finish up the dynamic sections.  */
15714
15715 static bfd_boolean
15716 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15717                                    struct bfd_link_info *info)
15718 {
15719   struct ppc_link_hash_table *htab;
15720   bfd *dynobj;
15721   asection *sdyn;
15722
15723   htab = ppc_hash_table (info);
15724   if (htab == NULL)
15725     return FALSE;
15726
15727   dynobj = htab->elf.dynobj;
15728   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15729
15730   if (htab->elf.dynamic_sections_created)
15731     {
15732       Elf64_External_Dyn *dyncon, *dynconend;
15733
15734       if (sdyn == NULL || htab->elf.sgot == NULL)
15735         abort ();
15736
15737       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15738       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15739       for (; dyncon < dynconend; dyncon++)
15740         {
15741           Elf_Internal_Dyn dyn;
15742           asection *s;
15743
15744           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15745
15746           switch (dyn.d_tag)
15747             {
15748             default:
15749               continue;
15750
15751             case DT_PPC64_GLINK:
15752               s = htab->glink;
15753               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15754               /* We stupidly defined DT_PPC64_GLINK to be the start
15755                  of glink rather than the first entry point, which is
15756                  what ld.so needs, and now have a bigger stub to
15757                  support automatic multiple TOCs.  */
15758               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15759               break;
15760
15761             case DT_PPC64_OPD:
15762               s = bfd_get_section_by_name (output_bfd, ".opd");
15763               if (s == NULL)
15764                 continue;
15765               dyn.d_un.d_ptr = s->vma;
15766               break;
15767
15768             case DT_PPC64_OPT:
15769               if (htab->do_multi_toc && htab->multi_toc_needed)
15770                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15771               if (htab->has_plt_localentry0)
15772                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15773               break;
15774
15775             case DT_PPC64_OPDSZ:
15776               s = bfd_get_section_by_name (output_bfd, ".opd");
15777               if (s == NULL)
15778                 continue;
15779               dyn.d_un.d_val = s->size;
15780               break;
15781
15782             case DT_PLTGOT:
15783               s = htab->elf.splt;
15784               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15785               break;
15786
15787             case DT_JMPREL:
15788               s = htab->elf.srelplt;
15789               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15790               break;
15791
15792             case DT_PLTRELSZ:
15793               dyn.d_un.d_val = htab->elf.srelplt->size;
15794               break;
15795
15796             case DT_TEXTREL:
15797               if (htab->local_ifunc_resolver)
15798                 info->callbacks->einfo
15799                   (_("%X%P: text relocations and GNU indirect "
15800                      "functions will result in a segfault at runtime\n"));
15801               else if (htab->maybe_local_ifunc_resolver)
15802                 info->callbacks->einfo
15803                   (_("%P: warning: text relocations and GNU indirect "
15804                      "functions may result in a segfault at runtime\n"));
15805               continue;
15806             }
15807
15808           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15809         }
15810     }
15811
15812   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15813       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15814     {
15815       /* Fill in the first entry in the global offset table.
15816          We use it to hold the link-time TOCbase.  */
15817       bfd_put_64 (output_bfd,
15818                   elf_gp (output_bfd) + TOC_BASE_OFF,
15819                   htab->elf.sgot->contents);
15820
15821       /* Set .got entry size.  */
15822       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15823     }
15824
15825   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15826       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15827     {
15828       /* Set .plt entry size.  */
15829       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15830         = PLT_ENTRY_SIZE (htab);
15831     }
15832
15833   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15834      brlt ourselves if emitrelocations.  */
15835   if (htab->brlt != NULL
15836       && htab->brlt->reloc_count != 0
15837       && !_bfd_elf_link_output_relocs (output_bfd,
15838                                        htab->brlt,
15839                                        elf_section_data (htab->brlt)->rela.hdr,
15840                                        elf_section_data (htab->brlt)->relocs,
15841                                        NULL))
15842     return FALSE;
15843
15844   if (htab->glink != NULL
15845       && htab->glink->reloc_count != 0
15846       && !_bfd_elf_link_output_relocs (output_bfd,
15847                                        htab->glink,
15848                                        elf_section_data (htab->glink)->rela.hdr,
15849                                        elf_section_data (htab->glink)->relocs,
15850                                        NULL))
15851     return FALSE;
15852
15853   if (htab->glink_eh_frame != NULL
15854       && htab->glink_eh_frame->size != 0)
15855     {
15856       bfd_vma val;
15857       bfd_byte *p;
15858       struct map_stub *group;
15859       size_t align = 4;
15860
15861       p = htab->glink_eh_frame->contents;
15862       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15863
15864       for (group = htab->group; group != NULL; group = group->next)
15865         if (group->stub_sec != NULL)
15866           {
15867             /* Offset to stub section.  */
15868             val = (group->stub_sec->output_section->vma
15869                    + group->stub_sec->output_offset);
15870             val -= (htab->glink_eh_frame->output_section->vma
15871                     + htab->glink_eh_frame->output_offset
15872                     + (p + 8 - htab->glink_eh_frame->contents));
15873             if (val + 0x80000000 > 0xffffffff)
15874               {
15875                 info->callbacks->einfo
15876                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15877                    group->stub_sec->name);
15878                 return FALSE;
15879               }
15880             bfd_put_32 (dynobj, val, p + 8);
15881             p += stub_eh_frame_size (group, align);
15882           }
15883       if (htab->glink != NULL && htab->glink->size != 0)
15884         {
15885           /* Offset to .glink.  */
15886           val = (htab->glink->output_section->vma
15887                  + htab->glink->output_offset
15888                  + 8);
15889           val -= (htab->glink_eh_frame->output_section->vma
15890                   + htab->glink_eh_frame->output_offset
15891                   + (p + 8 - htab->glink_eh_frame->contents));
15892           if (val + 0x80000000 > 0xffffffff)
15893             {
15894               info->callbacks->einfo
15895                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15896                  htab->glink->name);
15897               return FALSE;
15898             }
15899           bfd_put_32 (dynobj, val, p + 8);
15900           p += (24 + align - 1) & -align;
15901         }
15902
15903       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15904           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15905                                                htab->glink_eh_frame,
15906                                                htab->glink_eh_frame->contents))
15907         return FALSE;
15908     }
15909
15910   /* We need to handle writing out multiple GOT sections ourselves,
15911      since we didn't add them to DYNOBJ.  We know dynobj is the first
15912      bfd.  */
15913   while ((dynobj = dynobj->link.next) != NULL)
15914     {
15915       asection *s;
15916
15917       if (!is_ppc64_elf (dynobj))
15918         continue;
15919
15920       s = ppc64_elf_tdata (dynobj)->got;
15921       if (s != NULL
15922           && s->size != 0
15923           && s->output_section != bfd_abs_section_ptr
15924           && !bfd_set_section_contents (output_bfd, s->output_section,
15925                                         s->contents, s->output_offset,
15926                                         s->size))
15927         return FALSE;
15928       s = ppc64_elf_tdata (dynobj)->relgot;
15929       if (s != NULL
15930           && s->size != 0
15931           && s->output_section != bfd_abs_section_ptr
15932           && !bfd_set_section_contents (output_bfd, s->output_section,
15933                                         s->contents, s->output_offset,
15934                                         s->size))
15935         return FALSE;
15936     }
15937
15938   return TRUE;
15939 }
15940
15941 #include "elf64-target.h"
15942
15943 /* FreeBSD support */
15944
15945 #undef  TARGET_LITTLE_SYM
15946 #undef  TARGET_LITTLE_NAME
15947
15948 #undef  TARGET_BIG_SYM
15949 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15950 #undef  TARGET_BIG_NAME
15951 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15952
15953 #undef  ELF_OSABI
15954 #define ELF_OSABI       ELFOSABI_FREEBSD
15955
15956 #undef  elf64_bed
15957 #define elf64_bed       elf64_powerpc_fbsd_bed
15958
15959 #include "elf64-target.h"