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