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