bfd/elf64-ppc.c

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