bfd/elf64-ppc.c

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