bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2017 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_want_dynrelro 1
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_dtrel_excludes_plt 1
  80 #define elf_backend_default_execstack 0
  81
  82 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  83 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  84 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  87 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  92
  93 #define elf_backend_object_p                  ppc64_elf_object_p
  94 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  95 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  96 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  99 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 100 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 101 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 103 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 104 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 105 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 106 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 107 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 108 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 109 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 110 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 111 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 112 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 113 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 114 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 115 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 116 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 117 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 118 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 119 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 120 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 121 #define elf_backend_special_sections          ppc64_elf_special_sections
 122 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 123 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 124 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 125
 126 /* The name of the dynamic interpreter.  This is put in the .interp
 127    section.  */
 128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 129
 130 /* The size in bytes of an entry in the procedure linkage table.  */
 131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 132
 133 /* The initial size of the plt reserved for the dynamic linker.  */
 134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 135
 136 /* Offsets to some stack save slots.  */
 137 #define STK_LR 16
 138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 139 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 140    CR save slot.  Used only by optimised __tls_get_addr call stub,
 141    relying on __tls_get_addr_opt not saving CR..  */
 142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 143
 144 /* TOC base pointers offset from start of TOC.  */
 145 #define TOC_BASE_OFF    0x8000
 146 /* TOC base alignment.  */
 147 #define TOC_BASE_ALIGN  256
 148
 149 /* Offset of tp and dtp pointers from start of TLS block.  */
 150 #define TP_OFFSET       0x7000
 151 #define DTP_OFFSET      0x8000
 152
 153 /* .plt call stub instructions.  The normal stub is like this, but
 154    sometimes the .plt entry crosses a 64k boundary and we need to
 155    insert an addi to adjust r11.  */
 156 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 157 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 158 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 159 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 160 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 161 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 162 #define BCTR            0x4e800420      /* bctr                      */
 163
 164 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 165 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 166 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 167
 168 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 169 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 170 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 171 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 172 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 173 #define BNECTR          0x4ca20420      /* bnectr+               */
 174 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 175
 176 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 177 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 178 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 179
 180 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 181 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 182 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 183
 184 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 185 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 186 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 187 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 188 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 189
 190 /* glink call stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_CALL_STUB_SIZE (16*4)
 192                                         /* 0:                           */
 193                                         /*  .quad plt0-1f               */
 194                                         /* __glink:                     */
 195 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 196 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 197                                         /* 1:                           */
 198 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 199                                         /*  ld %2,(0b-1b)(%11)          */
 200 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 201 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 202                                         /*  ld %12,0(%11)               */
 203                                         /*  ld %2,8(%11)                */
 204                                         /*  mtctr %12                   */
 205                                         /*  ld %11,16(%11)              */
 206                                         /*  bctr                        */
 207 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 208 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 209 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 210 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 211 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 212
 213 /* Pad with this.  */
 214 #define NOP             0x60000000
 215
 216 /* Some other nops.  */
 217 #define CROR_151515     0x4def7b82
 218 #define CROR_313131     0x4ffffb82
 219
 220 /* .glink entries for the first 32k functions are two instructions.  */
 221 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 222 #define B_DOT           0x48000000      /* b     .              */
 223
 224 /* After that, we need two instructions to load the index, followed by
 225    a branch.  */
 226 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 227 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 228
 229 /* Instructions used by the save and restore reg functions.  */
 230 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 231 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 232 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 233 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 234 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 235 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 236 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 237 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 238 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 239 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 240 #define BLR             0x4e800020      /* blr                  */
 241
 242 /* Since .opd is an array of descriptors and each entry will end up
 243    with identical R_PPC64_RELATIVE relocs, there is really no need to
 244    propagate .opd relocs;  The dynamic linker should be taught to
 245    relocate .opd without reloc entries.  */
 246 #ifndef NO_OPD_RELOCS
 247 #define NO_OPD_RELOCS 0
 248 #endif
 249
 250 #ifndef ARRAY_SIZE
 251 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 252 #endif
 253
 254 static inline int
 255 abiversion (bfd *abfd)
 256 {
 257   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 258 }
 259
 260 static inline void
 261 set_abiversion (bfd *abfd, int ver)
 262 {
 263   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 264   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 265 }
 266 \f
 267 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 268
 269 /* Relocation HOWTO's.  */
 270 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 271
 272 static reloc_howto_type ppc64_elf_howto_raw[] = {
 273   /* This reloc does nothing.  */
 274   HOWTO (R_PPC64_NONE,          /* type */
 275          0,                     /* rightshift */
 276          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          0,                     /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_dont, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_NONE",        /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0,                     /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* A standard 32 bit relocation.  */
 289   HOWTO (R_PPC64_ADDR32,        /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          32,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_bitfield, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_PPC64_ADDR32",      /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0xffffffff,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   /* An absolute 26 bit branch; the lower two bits must be zero.
 304      FIXME: we don't check that, we just clear them.  */
 305   HOWTO (R_PPC64_ADDR24,        /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          26,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR24",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0x03fffffc,            /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A standard 16 bit relocation.  */
 320   HOWTO (R_PPC64_ADDR16,        /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_bitfield, /* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16",      /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* A 16 bit relocation without overflow.  */
 335   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 336          0,                     /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_dont,/* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_LO",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address.  */
 350   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 351          16,                    /* rightshift */
 352          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          FALSE,                 /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC64_ADDR16_HI",   /* name */
 359          FALSE,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xffff,                /* dst_mask */
 362          FALSE),                /* pcrel_offset */
 363
 364   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 365      bits, treated as a signed number, is negative.  */
 366   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 367          16,                    /* rightshift */
 368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          ppc64_elf_ha_reloc,    /* special_function */
 374          "R_PPC64_ADDR16_HA",   /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 16 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC64_ADDR14,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          16,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_signed, /* complain_on_overflow */
 389          ppc64_elf_branch_reloc, /* special_function */
 390          "R_PPC64_ADDR14",      /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x0000fffc,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* An absolute 16 bit branch, for which bit 10 should be set to
 397      indicate that the branch is expected to be taken.  The lower two
 398      bits must be zero.  */
 399   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 400          0,                     /* rightshift */
 401          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          FALSE,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          ppc64_elf_brtaken_reloc, /* special_function */
 407          "R_PPC64_ADDR14_BRTAKEN",/* name */
 408          FALSE,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0x0000fffc,            /* dst_mask */
 411          FALSE),                /* pcrel_offset */
 412
 413   /* An absolute 16 bit branch, for which bit 10 should be set to
 414      indicate that the branch is not expected to be taken.  The lower
 415      two bits must be zero.  */
 416   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          16,                    /* bitsize */
 420          FALSE,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_brtaken_reloc, /* special_function */
 424          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x0000fffc,            /* dst_mask */
 428          FALSE),                /* pcrel_offset */
 429
 430   /* A relative 26 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL24,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          26,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL24",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x03fffffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch; the lower two bits must be zero.  */
 446   HOWTO (R_PPC64_REL14,         /* type */
 447          0,                     /* rightshift */
 448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          16,                    /* bitsize */
 450          TRUE,                  /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          ppc64_elf_branch_reloc, /* special_function */
 454          "R_PPC64_REL14",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0,                     /* src_mask */
 457          0x0000fffc,            /* dst_mask */
 458          TRUE),                 /* pcrel_offset */
 459
 460   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 461      the branch is expected to be taken.  The lower two bits must be
 462      zero.  */
 463   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 464          0,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          16,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed, /* complain_on_overflow */
 470          ppc64_elf_brtaken_reloc, /* special_function */
 471          "R_PPC64_REL14_BRTAKEN", /* name */
 472          FALSE,                 /* partial_inplace */
 473          0,                     /* src_mask */
 474          0x0000fffc,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 478      the branch is not expected to be taken.  The lower two bits must
 479      be zero.  */
 480   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 481          0,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          16,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed, /* complain_on_overflow */
 487          ppc64_elf_brtaken_reloc, /* special_function */
 488          "R_PPC64_REL14_BRNTAKEN",/* name */
 489          FALSE,                 /* partial_inplace */
 490          0,                     /* src_mask */
 491          0x0000fffc,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 495      symbol.  */
 496   HOWTO (R_PPC64_GOT16,         /* type */
 497          0,                     /* rightshift */
 498          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_GOT16",       /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0xffff,                /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 511      the symbol.  */
 512   HOWTO (R_PPC64_GOT16_LO,      /* type */
 513          0,                     /* rightshift */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          16,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc, /* special_function */
 520          "R_PPC64_GOT16_LO",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          0xffff,                /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 527      the symbol.  */
 528   HOWTO (R_PPC64_GOT16_HI,      /* type */
 529          16,                    /* rightshift */
 530          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          16,                    /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed,/* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_GOT16_HI",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0xffff,                /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 543      the symbol.  */
 544   HOWTO (R_PPC64_GOT16_HA,      /* type */
 545          16,                    /* rightshift */
 546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          16,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,/* complain_on_overflow */
 551          ppc64_elf_unhandled_reloc, /* special_function */
 552          "R_PPC64_GOT16_HA",    /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0xffff,                /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* This is used only by the dynamic linker.  The symbol should exist
 559      both in the object being run and in some shared library.  The
 560      dynamic linker copies the data addressed by the symbol from the
 561      shared library into the object, because the object being
 562      run has to have the data at some particular address.  */
 563   HOWTO (R_PPC64_COPY,          /* type */
 564          0,                     /* rightshift */
 565          0,                     /* this one is variable size */
 566          0,                     /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          ppc64_elf_unhandled_reloc, /* special_function */
 571          "R_PPC64_COPY",        /* name */
 572          FALSE,                 /* partial_inplace */
 573          0,                     /* src_mask */
 574          0,                     /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* Like R_PPC64_ADDR64, but used when setting global offset table
 578      entries.  */
 579   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 580          0,                     /* rightshift */
 581          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 582          64,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          ppc64_elf_unhandled_reloc,  /* special_function */
 587          "R_PPC64_GLOB_DAT",    /* name */
 588          FALSE,                 /* partial_inplace */
 589          0,                     /* src_mask */
 590          ONES (64),             /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* Created by the link editor.  Marks a procedure linkage table
 594      entry for a symbol.  */
 595   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 596          0,                     /* rightshift */
 597          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          0,                     /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_dont, /* complain_on_overflow */
 602          ppc64_elf_unhandled_reloc, /* special_function */
 603          "R_PPC64_JMP_SLOT",    /* name */
 604          FALSE,                 /* partial_inplace */
 605          0,                     /* src_mask */
 606          0,                     /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* Used only by the dynamic linker.  When the object is run, this
 610      doubleword64 is set to the load address of the object, plus the
 611      addend.  */
 612   HOWTO (R_PPC64_RELATIVE,      /* type */
 613          0,                     /* rightshift */
 614          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 615          64,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_dont, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_RELATIVE",    /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          ONES (64),             /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR32,       /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          32,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR32",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffffffff,            /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 642   HOWTO (R_PPC64_UADDR16,       /* type */
 643          0,                     /* rightshift */
 644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          16,                    /* bitsize */
 646          FALSE,                 /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_bitfield, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_UADDR16",     /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffff,                /* dst_mask */
 654          FALSE),                /* pcrel_offset */
 655
 656   /* 32-bit PC relative.  */
 657   HOWTO (R_PPC64_REL32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_REL32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          TRUE),                 /* pcrel_offset */
 670
 671   /* 32-bit relocation to the symbol's procedure linkage table.  */
 672   HOWTO (R_PPC64_PLT32,         /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          ppc64_elf_unhandled_reloc, /* special_function */
 680          "R_PPC64_PLT32",       /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 687      FIXME: R_PPC64_PLTREL32 not supported.  */
 688   HOWTO (R_PPC64_PLTREL32,      /* type */
 689          0,                     /* rightshift */
 690          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 691          32,                    /* bitsize */
 692          TRUE,                  /* pc_relative */
 693          0,                     /* bitpos */
 694          complain_overflow_signed, /* complain_on_overflow */
 695          ppc64_elf_unhandled_reloc, /* special_function */
 696          "R_PPC64_PLTREL32",    /* name */
 697          FALSE,                 /* partial_inplace */
 698          0,                     /* src_mask */
 699          0xffffffff,            /* dst_mask */
 700          TRUE),                 /* pcrel_offset */
 701
 702   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 703      the symbol.  */
 704   HOWTO (R_PPC64_PLT16_LO,      /* type */
 705          0,                     /* rightshift */
 706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_dont, /* complain_on_overflow */
 711          ppc64_elf_unhandled_reloc, /* special_function */
 712          "R_PPC64_PLT16_LO",    /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffff,                /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 719      the symbol.  */
 720   HOWTO (R_PPC64_PLT16_HI,      /* type */
 721          16,                    /* rightshift */
 722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          FALSE,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_signed, /* complain_on_overflow */
 727          ppc64_elf_unhandled_reloc, /* special_function */
 728          "R_PPC64_PLT16_HI",    /* name */
 729          FALSE,                 /* partial_inplace */
 730          0,                     /* src_mask */
 731          0xffff,                /* dst_mask */
 732          FALSE),                /* pcrel_offset */
 733
 734   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 735      the symbol.  */
 736   HOWTO (R_PPC64_PLT16_HA,      /* type */
 737          16,                    /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_unhandled_reloc, /* special_function */
 744          "R_PPC64_PLT16_HA",    /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit section relative relocation.  */
 751   HOWTO (R_PPC64_SECTOFF,       /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF",     /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 766   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 767          0,                     /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_dont, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_LO",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HI",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* 16-bit upper half adjusted section relative relocation.  */
 796   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 797          16,                    /* rightshift */
 798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          FALSE,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          ppc64_elf_sectoff_ha_reloc, /* special_function */
 804          "R_PPC64_SECTOFF_HA",  /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xffff,                /* dst_mask */
 808          FALSE),                /* pcrel_offset */
 809
 810   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 811   HOWTO (R_PPC64_REL30,         /* type */
 812          2,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          30,                    /* bitsize */
 815          TRUE,                  /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_PPC64_REL30",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xfffffffc,            /* dst_mask */
 823          TRUE),                 /* pcrel_offset */
 824
 825   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 826
 827   /* A standard 64-bit relocation.  */
 828   HOWTO (R_PPC64_ADDR64,        /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR64",      /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          ONES (64),             /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address.  */
 843   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 844          32,                    /* rightshift */
 845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          16,                    /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_ADDR16_HIGHER", /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0xffff,                /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   /* The bits 32-47 of an address, plus 1 if the contents of the low
 858      16 bits, treated as a signed number, is negative.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 860          32,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          ppc64_elf_ha_reloc,    /* special_function */
 867          "R_PPC64_ADDR16_HIGHERA", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address.  */
 874   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 875          48,                    /* rightshift */
 876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          16,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          0,                     /* bitpos */
 880          complain_overflow_dont, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_PPC64_ADDR16_HIGHEST", /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffff,                /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* The bits 48-63 of an address, plus 1 if the contents of the low
 889      16 bits, treated as a signed number, is negative.  */
 890   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 891          48,                    /* rightshift */
 892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          ppc64_elf_ha_reloc,    /* special_function */
 898          "R_PPC64_ADDR16_HIGHESTA", /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0xffff,                /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* Like ADDR64, but may be unaligned.  */
 905   HOWTO (R_PPC64_UADDR64,       /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          FALSE,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_UADDR64",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          FALSE),                /* pcrel_offset */
 918
 919   /* 64-bit relative relocation.  */
 920   HOWTO (R_PPC64_REL64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          TRUE,                  /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_PPC64_REL64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          TRUE),                 /* pcrel_offset */
 933
 934   /* 64-bit relocation to the symbol's procedure linkage table.  */
 935   HOWTO (R_PPC64_PLT64,         /* type */
 936          0,                     /* rightshift */
 937          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 938          64,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_unhandled_reloc, /* special_function */
 943          "R_PPC64_PLT64",       /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          ONES (64),             /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 64-bit PC relative relocation to the symbol's procedure linkage
 950      table.  */
 951   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 952   HOWTO (R_PPC64_PLTREL64,      /* type */
 953          0,                     /* rightshift */
 954          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 955          64,                    /* bitsize */
 956          TRUE,                  /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_unhandled_reloc, /* special_function */
 960          "R_PPC64_PLTREL64",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          ONES (64),             /* dst_mask */
 964          TRUE),                 /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation.  */
 967
 968   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 969   HOWTO (R_PPC64_TOC16,         /* type */
 970          0,                     /* rightshift */
 971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 972          16,                    /* bitsize */
 973          FALSE,                 /* pc_relative */
 974          0,                     /* bitpos */
 975          complain_overflow_signed, /* complain_on_overflow */
 976          ppc64_elf_toc_reloc,   /* special_function */
 977          "R_PPC64_TOC16",       /* name */
 978          FALSE,                 /* partial_inplace */
 979          0,                     /* src_mask */
 980          0xffff,                /* dst_mask */
 981          FALSE),                /* pcrel_offset */
 982
 983   /* 16 bit TOC-relative relocation without overflow.  */
 984
 985   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 986   HOWTO (R_PPC64_TOC16_LO,      /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          FALSE,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          ppc64_elf_toc_reloc,   /* special_function */
 994          "R_PPC64_TOC16_LO",    /* name */
 995          FALSE,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          FALSE),                /* pcrel_offset */
 999
1000   /* 16 bit TOC-relative relocation, high 16 bits.  */
1001
1002   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1003   HOWTO (R_PPC64_TOC16_HI,      /* type */
1004          16,                    /* rightshift */
1005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          16,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_signed, /* complain_on_overflow */
1010          ppc64_elf_toc_reloc,   /* special_function */
1011          "R_PPC64_TOC16_HI",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0,                     /* src_mask */
1014          0xffff,                /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016
1017   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018      contents of the low 16 bits, treated as a signed number, is
1019      negative.  */
1020
1021   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1022   HOWTO (R_PPC64_TOC16_HA,      /* type */
1023          16,                    /* rightshift */
1024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1025          16,                    /* bitsize */
1026          FALSE,                 /* pc_relative */
1027          0,                     /* bitpos */
1028          complain_overflow_signed, /* complain_on_overflow */
1029          ppc64_elf_toc_ha_reloc, /* special_function */
1030          "R_PPC64_TOC16_HA",    /* name */
1031          FALSE,                 /* partial_inplace */
1032          0,                     /* src_mask */
1033          0xffff,                /* dst_mask */
1034          FALSE),                /* pcrel_offset */
1035
1036   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1037
1038   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1039   HOWTO (R_PPC64_TOC,           /* type */
1040          0,                     /* rightshift */
1041          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042          64,                    /* bitsize */
1043          FALSE,                 /* pc_relative */
1044          0,                     /* bitpos */
1045          complain_overflow_dont, /* complain_on_overflow */
1046          ppc64_elf_toc64_reloc, /* special_function */
1047          "R_PPC64_TOC",         /* name */
1048          FALSE,                 /* partial_inplace */
1049          0,                     /* src_mask */
1050          ONES (64),             /* dst_mask */
1051          FALSE),                /* pcrel_offset */
1052
1053   /* Like R_PPC64_GOT16, but also informs the link editor that the
1054      value to relocate may (!) refer to a PLT entry which the link
1055      editor (a) may replace with the symbol value.  If the link editor
1056      is unable to fully resolve the symbol, it may (b) create a PLT
1057      entry and store the address to the new PLT entry in the GOT.
1058      This permits lazy resolution of function symbols at run time.
1059      The link editor may also skip all of this and just (c) emit a
1060      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1061   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1062     HOWTO (R_PPC64_PLTGOT16,    /* type */
1063          0,                     /* rightshift */
1064          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_signed, /* complain_on_overflow */
1069          ppc64_elf_unhandled_reloc, /* special_function */
1070          "R_PPC64_PLTGOT16",    /* name */
1071          FALSE,                 /* partial_inplace */
1072          0,                     /* src_mask */
1073          0xffff,                /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1077   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1078   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1079          0,                     /* rightshift */
1080          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1081          16,                    /* bitsize */
1082          FALSE,                 /* pc_relative */
1083          0,                     /* bitpos */
1084          complain_overflow_dont, /* complain_on_overflow */
1085          ppc64_elf_unhandled_reloc, /* special_function */
1086          "R_PPC64_PLTGOT16_LO", /* name */
1087          FALSE,                 /* partial_inplace */
1088          0,                     /* src_mask */
1089          0xffff,                /* dst_mask */
1090          FALSE),                /* pcrel_offset */
1091
1092   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1093   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1094   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1095          16,                    /* rightshift */
1096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1097          16,                    /* bitsize */
1098          FALSE,                 /* pc_relative */
1099          0,                     /* bitpos */
1100          complain_overflow_signed, /* complain_on_overflow */
1101          ppc64_elf_unhandled_reloc, /* special_function */
1102          "R_PPC64_PLTGOT16_HI", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109      1 if the contents of the low 16 bits, treated as a signed number,
1110      is negative.  */
1111   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1112   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1113          16,                    /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          ppc64_elf_unhandled_reloc, /* special_function */
1120          "R_PPC64_PLTGOT16_HA", /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xffff,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_signed, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_DS",   /* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_dont,/* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_ADDR16_LO_DS",/* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_DS,      /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_signed, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_DS",    /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_GOT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont, /* complain_on_overflow */
1194          ppc64_elf_unhandled_reloc, /* special_function */
1195          "R_PPC64_PLT16_LO_DS", /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_signed, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_DS",  /* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont, /* complain_on_overflow */
1224          ppc64_elf_sectoff_reloc, /* special_function */
1225          "R_PPC64_SECTOFF_LO_DS",/* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_DS,      /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_signed, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_DS",    /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1247   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1248          0,                     /* rightshift */
1249          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          16,                    /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont, /* complain_on_overflow */
1254          ppc64_elf_toc_reloc,   /* special_function */
1255          "R_PPC64_TOC16_LO_DS", /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0xfffc,                /* dst_mask */
1259          FALSE),                /* pcrel_offset */
1260
1261   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1262   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1263   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1264          0,                     /* rightshift */
1265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          16,                    /* bitsize */
1267          FALSE,                 /* pc_relative */
1268          0,                     /* bitpos */
1269          complain_overflow_signed, /* complain_on_overflow */
1270          ppc64_elf_unhandled_reloc, /* special_function */
1271          "R_PPC64_PLTGOT16_DS", /* name */
1272          FALSE,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0xfffc,                /* dst_mask */
1275          FALSE),                /* pcrel_offset */
1276
1277   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1278   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1279   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280          0,                     /* rightshift */
1281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          16,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          ppc64_elf_unhandled_reloc, /* special_function */
1287          "R_PPC64_PLTGOT16_LO_DS",/* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xfffc,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* Marker relocs for TLS.  */
1294   HOWTO (R_PPC64_TLS,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLS",         /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TLSGD,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TLSGD",       /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   HOWTO (R_PPC64_TLSLD,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLSLD",       /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TOCSAVE,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TOCSAVE",     /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Computes the load module index of the load module that contains the
1351      definition of its TLS sym.  */
1352   HOWTO (R_PPC64_DTPMOD64,
1353          0,                     /* rightshift */
1354          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          64,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc64_elf_unhandled_reloc, /* special_function */
1360          "R_PPC64_DTPMOD64",    /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          ONES (64),             /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* Computes a dtv-relative displacement, the difference between the value
1367      of sym+add and the base address of the thread-local storage block that
1368      contains the definition of sym, minus 0x8000.  */
1369   HOWTO (R_PPC64_DTPREL64,
1370          0,                     /* rightshift */
1371          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          64,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL64",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          ONES (64),             /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* A 16 bit dtprel reloc.  */
1384   HOWTO (R_PPC64_DTPREL16,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16",    /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16, but no overflow.  */
1399   HOWTO (R_PPC64_DTPREL16_LO,
1400          0,                     /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_dont, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_LO", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HI,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HI", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HA,
1430          16,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_signed, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HA", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHER,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHER", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460          32,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHERA", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHEST", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1489   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490          48,                    /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_dont, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xffff,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16, but for insns with a DS field.  */
1504   HOWTO (R_PPC64_DTPREL16_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_signed, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Like DTPREL16_DS, but no overflow.  */
1519   HOWTO (R_PPC64_DTPREL16_LO_DS,
1520          0,                     /* rightshift */
1521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          16,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_dont, /* complain_on_overflow */
1526          ppc64_elf_unhandled_reloc, /* special_function */
1527          "R_PPC64_DTPREL16_LO_DS", /* name */
1528          FALSE,                 /* partial_inplace */
1529          0,                     /* src_mask */
1530          0xfffc,                /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   /* Computes a tp-relative displacement, the difference between the value of
1534      sym+add and the value of the thread pointer (r13).  */
1535   HOWTO (R_PPC64_TPREL64,
1536          0,                     /* rightshift */
1537          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          64,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_dont, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL64",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          ONES (64),             /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* A 16 bit tprel reloc.  */
1550   HOWTO (R_PPC64_TPREL16,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_signed, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16",     /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16, but no overflow.  */
1565   HOWTO (R_PPC64_TPREL16_LO,
1566          0,                     /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_dont, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_LO",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HI,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HI",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HA,
1596          16,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_signed, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HA",  /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHER,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHER",      /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHERA,
1626          32,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHERA", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHEST,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHEST", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1655   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656          48,                    /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_dont, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_HIGHESTA", /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xffff,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16, but for insns with a DS field.  */
1670   HOWTO (R_PPC64_TPREL16_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_signed, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_DS",  /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Like TPREL16_DS, but no overflow.  */
1685   HOWTO (R_PPC64_TPREL16_LO_DS,
1686          0,                     /* rightshift */
1687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1688          16,                    /* bitsize */
1689          FALSE,                 /* pc_relative */
1690          0,                     /* bitpos */
1691          complain_overflow_dont, /* complain_on_overflow */
1692          ppc64_elf_unhandled_reloc, /* special_function */
1693          "R_PPC64_TPREL16_LO_DS", /* name */
1694          FALSE,                 /* partial_inplace */
1695          0,                     /* src_mask */
1696          0xfffc,                /* dst_mask */
1697          FALSE),                /* pcrel_offset */
1698
1699   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701      to the first entry relative to the TOC base (r2).  */
1702   HOWTO (R_PPC64_GOT_TLSGD16,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_signed, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16, but no overflow.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_dont, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_LO", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HI", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1747   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_signed, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_TLSGD16_HA", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762      with values (sym+add)@dtpmod and zero, and computes the offset to the
1763      first entry relative to the TOC base (r2).  */
1764   HOWTO (R_PPC64_GOT_TLSLD16,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_signed, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16, but no overflow.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_dont, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_LO", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HI", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1809   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810          16,                    /* rightshift */
1811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1812          16,                    /* bitsize */
1813          FALSE,                 /* pc_relative */
1814          0,                     /* bitpos */
1815          complain_overflow_signed, /* complain_on_overflow */
1816          ppc64_elf_unhandled_reloc, /* special_function */
1817          "R_PPC64_GOT_TLSLD16_HA", /* name */
1818          FALSE,                 /* partial_inplace */
1819          0,                     /* src_mask */
1820          0xffff,                /* dst_mask */
1821          FALSE),                /* pcrel_offset */
1822
1823   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824      the offset to the entry relative to the TOC base (r2).  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_signed, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_DS, but no overflow.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841          0,                     /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_dont, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xfffc,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HI", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1870   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871          16,                    /* rightshift */
1872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1873          16,                    /* bitsize */
1874          FALSE,                 /* pc_relative */
1875          0,                     /* bitpos */
1876          complain_overflow_signed, /* complain_on_overflow */
1877          ppc64_elf_unhandled_reloc, /* special_function */
1878          "R_PPC64_GOT_DTPREL16_HA", /* name */
1879          FALSE,                 /* partial_inplace */
1880          0,                     /* src_mask */
1881          0xffff,                /* dst_mask */
1882          FALSE),                /* pcrel_offset */
1883
1884   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885      offset to the entry relative to the TOC base (r2).  */
1886   HOWTO (R_PPC64_GOT_TPREL16_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_signed, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_DS, but no overflow.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902          0,                     /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_dont, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xfffc,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HI,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HI", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1931   HOWTO (R_PPC64_GOT_TPREL16_HA,
1932          16,                    /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_signed, /* complain_on_overflow */
1938          ppc64_elf_unhandled_reloc, /* special_function */
1939          "R_PPC64_GOT_TPREL16_HA", /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   HOWTO (R_PPC64_JMP_IREL,      /* type */
1946          0,                     /* rightshift */
1947          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948          0,                     /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_dont, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_JMP_IREL",    /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0,                     /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   HOWTO (R_PPC64_IRELATIVE,     /* type */
1960          0,                     /* rightshift */
1961          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962          64,                    /* bitsize */
1963          FALSE,                 /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_dont, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_IRELATIVE",   /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          ONES (64),             /* dst_mask */
1971          FALSE),                /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation.  */
1974   HOWTO (R_PPC64_REL16,         /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_signed, /* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16",       /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* A 16 bit relative relocation without overflow.  */
1989   HOWTO (R_PPC64_REL16_LO,      /* type */
1990          0,                     /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_dont,/* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_LO",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address.  */
2004   HOWTO (R_PPC64_REL16_HI,      /* type */
2005          16,                    /* rightshift */
2006          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2007          16,                    /* bitsize */
2008          TRUE,                  /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_signed, /* complain_on_overflow */
2011          bfd_elf_generic_reloc, /* special_function */
2012          "R_PPC64_REL16_HI",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0xffff,                /* dst_mask */
2016          TRUE),                 /* pcrel_offset */
2017
2018   /* The high order 16 bits of a relative address, plus 1 if the contents of
2019      the low 16 bits, treated as a signed number, is negative.  */
2020   HOWTO (R_PPC64_REL16_HA,      /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          TRUE,                  /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_signed, /* complain_on_overflow */
2027          ppc64_elf_ha_reloc,    /* special_function */
2028          "R_PPC64_REL16_HA",    /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          TRUE),                 /* pcrel_offset */
2033
2034   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2035   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2036          16,                    /* rightshift */
2037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          TRUE,                  /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_signed, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_REL16DX_HA",  /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0x1fffc1,              /* dst_mask */
2047          TRUE),                 /* pcrel_offset */
2048
2049   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2050   HOWTO (R_PPC64_16DX_HA,       /* type */
2051          16,                    /* rightshift */
2052          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_signed, /* complain_on_overflow */
2057          ppc64_elf_ha_reloc,    /* special_function */
2058          "R_PPC64_16DX_HA",     /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0x1fffc1,              /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2065   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          bfd_elf_generic_reloc, /* special_function */
2073          "R_PPC64_ADDR16_HIGH", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2080   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_ha_reloc,    /* special_function */
2088          "R_PPC64_ADDR16_HIGHA",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2095   HOWTO (R_PPC64_DTPREL16_HIGH,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_DTPREL16_HIGH", /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2110   HOWTO (R_PPC64_DTPREL16_HIGHA,
2111          16,                    /* rightshift */
2112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2113          16,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          ppc64_elf_unhandled_reloc, /* special_function */
2118          "R_PPC64_DTPREL16_HIGHA", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          0xffff,                /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2125   HOWTO (R_PPC64_TPREL16_HIGH,
2126          16,                    /* rightshift */
2127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          16,                    /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          ppc64_elf_unhandled_reloc, /* special_function */
2133          "R_PPC64_TPREL16_HIGH",        /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0xffff,                /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2140   HOWTO (R_PPC64_TPREL16_HIGHA,
2141          16,                    /* rightshift */
2142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          16,                    /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          ppc64_elf_unhandled_reloc, /* special_function */
2148          "R_PPC64_TPREL16_HIGHA",       /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0xffff,                /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153
2154   /* Marker reloc on ELFv2 large-model function entry.  */
2155   HOWTO (R_PPC64_ENTRY,
2156          0,                     /* rightshift */
2157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2158          32,                    /* bitsize */
2159          FALSE,                 /* pc_relative */
2160          0,                     /* bitpos */
2161          complain_overflow_dont, /* complain_on_overflow */
2162          bfd_elf_generic_reloc, /* special_function */
2163          "R_PPC64_ENTRY",       /* name */
2164          FALSE,                 /* partial_inplace */
2165          0,                     /* src_mask */
2166          0,                     /* dst_mask */
2167          FALSE),                /* pcrel_offset */
2168
2169   /* Like ADDR64, but use local entry point of function.  */
2170   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2171          0,                     /* rightshift */
2172          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173          64,                    /* bitsize */
2174          FALSE,                 /* pc_relative */
2175          0,                     /* bitpos */
2176          complain_overflow_dont, /* complain_on_overflow */
2177          bfd_elf_generic_reloc, /* special_function */
2178          "R_PPC64_ADDR64_LOCAL", /* name */
2179          FALSE,                 /* partial_inplace */
2180          0,                     /* src_mask */
2181          ONES (64),             /* dst_mask */
2182          FALSE),                /* pcrel_offset */
2183
2184   /* GNU extension to record C++ vtable hierarchy.  */
2185   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186          0,                     /* rightshift */
2187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2188          0,                     /* bitsize */
2189          FALSE,                 /* pc_relative */
2190          0,                     /* bitpos */
2191          complain_overflow_dont, /* complain_on_overflow */
2192          NULL,                  /* special_function */
2193          "R_PPC64_GNU_VTINHERIT", /* name */
2194          FALSE,                 /* partial_inplace */
2195          0,                     /* src_mask */
2196          0,                     /* dst_mask */
2197          FALSE),                /* pcrel_offset */
2198
2199   /* GNU extension to record C++ vtable member usage.  */
2200   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2201          0,                     /* rightshift */
2202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          0,                     /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont, /* complain_on_overflow */
2207          NULL,                  /* special_function */
2208          "R_PPC64_GNU_VTENTRY", /* name */
2209          FALSE,                 /* partial_inplace */
2210          0,                     /* src_mask */
2211          0,                     /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213 };
2214
2215 \f
2216 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217    be done.  */
2218
2219 static void
2220 ppc_howto_init (void)
2221 {
2222   unsigned int i, type;
2223
2224   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225     {
2226       type = ppc64_elf_howto_raw[i].type;
2227       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2228       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229     }
2230 }
2231
2232 static reloc_howto_type *
2233 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234                              bfd_reloc_code_real_type code)
2235 {
2236   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237
2238   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239     /* Initialize howto table if needed.  */
2240     ppc_howto_init ();
2241
2242   switch (code)
2243     {
2244     default:
2245       return NULL;
2246
2247     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2248       break;
2249     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2250       break;
2251     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2252       break;
2253     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2254       break;
2255     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2256       break;
2257     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2258       break;
2259     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2260       break;
2261     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2262       break;
2263     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2264       break;
2265     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2266       break;
2267     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2268       break;
2269     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2270       break;
2271     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2272       break;
2273     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2274       break;
2275     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2278       break;
2279     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2280       break;
2281     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2282       break;
2283     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2284       break;
2285     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2286       break;
2287     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2288       break;
2289     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2290       break;
2291     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2292       break;
2293     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2294       break;
2295     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2296       break;
2297     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2298       break;
2299     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2300       break;
2301     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2302       break;
2303     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2304       break;
2305     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2306       break;
2307     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2308       break;
2309     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2310       break;
2311     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2312       break;
2313     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2314       break;
2315     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2316       break;
2317     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2318       break;
2319     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2322       break;
2323     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2324       break;
2325     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2326       break;
2327     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2328       break;
2329     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2330       break;
2331     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2332       break;
2333     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2334       break;
2335     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2336       break;
2337     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2338       break;
2339     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2340       break;
2341     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2342       break;
2343     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2348       break;
2349     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2350       break;
2351     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2352       break;
2353     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2358       break;
2359     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2362       break;
2363     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2364       break;
2365     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2366       break;
2367     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2368       break;
2369     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2370       break;
2371     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2372       break;
2373     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2374       break;
2375     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2376       break;
2377     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2378       break;
2379     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2380       break;
2381     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2388       break;
2389     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2390       break;
2391     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2392       break;
2393     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2394       break;
2395     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2402       break;
2403     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2408       break;
2409     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2428       break;
2429     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2436       break;
2437     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2438       break;
2439     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2440       break;
2441     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2448       break;
2449     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2450       break;
2451     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2452       break;
2453     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2460       break;
2461     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2462       break;
2463     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2464       break;
2465     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2466       break;
2467     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2468       break;
2469     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2470       break;
2471     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2472       break;
2473     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2474       break;
2475     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2476       break;
2477     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2478       break;
2479     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2480       break;
2481     }
2482
2483   return ppc64_elf_howto_table[r];
2484 };
2485
2486 static reloc_howto_type *
2487 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488                              const char *r_name)
2489 {
2490   unsigned int i;
2491
2492   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2493     if (ppc64_elf_howto_raw[i].name != NULL
2494         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495       return &ppc64_elf_howto_raw[i];
2496
2497   return NULL;
2498 }
2499
2500 /* Set the howto pointer for a PowerPC ELF reloc.  */
2501
2502 static void
2503 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2504                          Elf_Internal_Rela *dst)
2505 {
2506   unsigned int type;
2507
2508   /* Initialize howto table if needed.  */
2509   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2510     ppc_howto_init ();
2511
2512   type = ELF64_R_TYPE (dst->r_info);
2513   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514     {
2515       /* xgettext:c-format */
2516       _bfd_error_handler (_("%B: invalid relocation type %d"),
2517                           abfd, (int) type);
2518       type = R_PPC64_NONE;
2519     }
2520   cache_ptr->howto = ppc64_elf_howto_table[type];
2521 }
2522
2523 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                     void *data, asection *input_section,
2528                     bfd *output_bfd, char **error_message)
2529 {
2530   enum elf_ppc64_reloc_type r_type;
2531   long insn;
2532   bfd_size_type octets;
2533   bfd_vma value;
2534
2535   /* If this is a relocatable link (output_bfd test tells us), just
2536      call the generic function.  Any adjustment will be done at final
2537      link time.  */
2538   if (output_bfd != NULL)
2539     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540                                   input_section, output_bfd, error_message);
2541
2542   /* Adjust the addend for sign extension of the low 16 bits.
2543      We won't actually be using the low 16 bits, so trashing them
2544      doesn't matter.  */
2545   reloc_entry->addend += 0x8000;
2546   r_type = reloc_entry->howto->type;
2547   if (r_type != R_PPC64_REL16DX_HA)
2548     return bfd_reloc_continue;
2549
2550   value = 0;
2551   if (!bfd_is_com_section (symbol->section))
2552     value = symbol->value;
2553   value += (reloc_entry->addend
2554             + symbol->section->output_offset
2555             + symbol->section->output_section->vma);
2556   value -= (reloc_entry->address
2557             + input_section->output_offset
2558             + input_section->output_section->vma);
2559   value = (bfd_signed_vma) value >> 16;
2560
2561   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563   insn &= ~0x1fffc1;
2564   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2565   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2566   if (value + 0x8000 > 0xffff)
2567     return bfd_reloc_overflow;
2568   return bfd_reloc_ok;
2569 }
2570
2571 static bfd_reloc_status_type
2572 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573                         void *data, asection *input_section,
2574                         bfd *output_bfd, char **error_message)
2575 {
2576   if (output_bfd != NULL)
2577     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578                                   input_section, output_bfd, error_message);
2579
2580   if (strcmp (symbol->section->name, ".opd") == 0
2581       && (symbol->section->owner->flags & DYNAMIC) == 0)
2582     {
2583       bfd_vma dest = opd_entry_value (symbol->section,
2584                                       symbol->value + reloc_entry->addend,
2585                                       NULL, NULL, FALSE);
2586       if (dest != (bfd_vma) -1)
2587         reloc_entry->addend = dest - (symbol->value
2588                                       + symbol->section->output_section->vma
2589                                       + symbol->section->output_offset);
2590     }
2591   else
2592     {
2593       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595       if (symbol->section->owner != abfd
2596           && symbol->section->owner != NULL
2597           && abiversion (symbol->section->owner) >= 2)
2598         {
2599           unsigned int i;
2600
2601           for (i = 0; i < symbol->section->owner->symcount; ++i)
2602             {
2603               asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605               if (strcmp (symdef->name, symbol->name) == 0)
2606                 {
2607                   elfsym = (elf_symbol_type *) symdef;
2608                   break;
2609                 }
2610             }
2611         }
2612       reloc_entry->addend
2613         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614     }
2615   return bfd_reloc_continue;
2616 }
2617
2618 static bfd_reloc_status_type
2619 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620                          void *data, asection *input_section,
2621                          bfd *output_bfd, char **error_message)
2622 {
2623   long insn;
2624   enum elf_ppc64_reloc_type r_type;
2625   bfd_size_type octets;
2626   /* Assume 'at' branch hints.  */
2627   bfd_boolean is_isa_v2 = TRUE;
2628
2629   /* If this is a relocatable link (output_bfd test tells us), just
2630      call the generic function.  Any adjustment will be done at final
2631      link time.  */
2632   if (output_bfd != NULL)
2633     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2634                                   input_section, output_bfd, error_message);
2635
2636   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638   insn &= ~(0x01 << 21);
2639   r_type = reloc_entry->howto->type;
2640   if (r_type == R_PPC64_ADDR14_BRTAKEN
2641       || r_type == R_PPC64_REL14_BRTAKEN)
2642     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2643
2644   if (is_isa_v2)
2645     {
2646       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2647          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2649       if ((insn & (0x14 << 21)) == (0x04 << 21))
2650         insn |= 0x02 << 21;
2651       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652         insn |= 0x08 << 21;
2653       else
2654         goto out;
2655     }
2656   else
2657     {
2658       bfd_vma target = 0;
2659       bfd_vma from;
2660
2661       if (!bfd_is_com_section (symbol->section))
2662         target = symbol->value;
2663       target += symbol->section->output_section->vma;
2664       target += symbol->section->output_offset;
2665       target += reloc_entry->addend;
2666
2667       from = (reloc_entry->address
2668               + input_section->output_offset
2669               + input_section->output_section->vma);
2670
2671       /* Invert 'y' bit if not the default.  */
2672       if ((bfd_signed_vma) (target - from) < 0)
2673         insn ^= 0x01 << 21;
2674     }
2675   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676  out:
2677   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678                                  input_section, output_bfd, error_message);
2679 }
2680
2681 static bfd_reloc_status_type
2682 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683                          void *data, asection *input_section,
2684                          bfd *output_bfd, char **error_message)
2685 {
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   /* Subtract the symbol section base address.  */
2694   reloc_entry->addend -= symbol->section->output_section->vma;
2695   return bfd_reloc_continue;
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700                             void *data, asection *input_section,
2701                             bfd *output_bfd, char **error_message)
2702 {
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   /* Subtract the symbol section base address.  */
2711   reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713   /* Adjust the addend for sign extension of the low 16 bits.  */
2714   reloc_entry->addend += 0x8000;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                      void *data, asection *input_section,
2721                      bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738   return bfd_reloc_continue;
2739 }
2740
2741 static bfd_reloc_status_type
2742 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743                         void *data, asection *input_section,
2744                         bfd *output_bfd, char **error_message)
2745 {
2746   bfd_vma TOCstart;
2747
2748   /* If this is a relocatable link (output_bfd test tells us), just
2749      call the generic function.  Any adjustment will be done at final
2750      link time.  */
2751   if (output_bfd != NULL)
2752     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2753                                   input_section, output_bfd, error_message);
2754
2755   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756   if (TOCstart == 0)
2757     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758
2759   /* Subtract the TOC base address.  */
2760   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                        void *data, asection *input_section,
2770                        bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773   bfd_size_type octets;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788   return bfd_reloc_ok;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                            void *data, asection *input_section,
2794                            bfd *output_bfd, char **error_message)
2795 {
2796   /* If this is a relocatable link (output_bfd test tells us), just
2797      call the generic function.  Any adjustment will be done at final
2798      link time.  */
2799   if (output_bfd != NULL)
2800     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2801                                   input_section, output_bfd, error_message);
2802
2803   if (error_message != NULL)
2804     {
2805       static char buf[60];
2806       sprintf (buf, "generic linker can't handle %s",
2807                reloc_entry->howto->name);
2808       *error_message = buf;
2809     }
2810   return bfd_reloc_dangerous;
2811 }
2812
2813 /* Track GOT entries needed for a given symbol.  We might need more
2814    than one got entry per symbol.  */
2815 struct got_entry
2816 {
2817   struct got_entry *next;
2818
2819   /* The symbol addend that we'll be placing in the GOT.  */
2820   bfd_vma addend;
2821
2822   /* Unlike other ELF targets, we use separate GOT entries for the same
2823      symbol referenced from different input files.  This is to support
2824      automatic multiple TOC/GOT sections, where the TOC base can vary
2825      from one input file to another.  After partitioning into TOC groups
2826      we merge entries within the group.
2827
2828      Point to the BFD owning this GOT entry.  */
2829   bfd *owner;
2830
2831   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832      TLS_TPREL or TLS_DTPREL for tls entries.  */
2833   unsigned char tls_type;
2834
2835   /* Non-zero if got.ent points to real entry.  */
2836   unsigned char is_indirect;
2837
2838   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2839   union
2840     {
2841       bfd_signed_vma refcount;
2842       bfd_vma offset;
2843       struct got_entry *ent;
2844     } got;
2845 };
2846
2847 /* The same for PLT.  */
2848 struct plt_entry
2849 {
2850   struct plt_entry *next;
2851
2852   bfd_vma addend;
2853
2854   union
2855     {
2856       bfd_signed_vma refcount;
2857       bfd_vma offset;
2858     } plt;
2859 };
2860
2861 struct ppc64_elf_obj_tdata
2862 {
2863   struct elf_obj_tdata elf;
2864
2865   /* Shortcuts to dynamic linker sections.  */
2866   asection *got;
2867   asection *relgot;
2868
2869   /* Used during garbage collection.  We attach global symbols defined
2870      on removed .opd entries to this section so that the sym is removed.  */
2871   asection *deleted_section;
2872
2873   /* TLS local dynamic got entry handling.  Support for multiple GOT
2874      sections means we potentially need one of these for each input bfd.  */
2875   struct got_entry tlsld_got;
2876
2877   union {
2878     /* A copy of relocs before they are modified for --emit-relocs.  */
2879     Elf_Internal_Rela *relocs;
2880
2881     /* Section contents.  */
2882     bfd_byte *contents;
2883   } opd;
2884
2885   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886      the reloc to be in the range -32768 to 32767.  */
2887   unsigned int has_small_toc_reloc : 1;
2888
2889   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890      instruction not one we handle.  */
2891   unsigned int unexpected_toc_insn : 1;
2892 };
2893
2894 #define ppc64_elf_tdata(bfd) \
2895   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897 #define ppc64_tlsld_got(bfd) \
2898   (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
2900 #define is_ppc64_elf(bfd) \
2901   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2902    && elf_object_id (bfd) == PPC64_ELF_DATA)
2903
2904 /* Override the generic function because we store some extras.  */
2905
2906 static bfd_boolean
2907 ppc64_elf_mkobject (bfd *abfd)
2908 {
2909   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2910                                   PPC64_ELF_DATA);
2911 }
2912
2913 /* Fix bad default arch selected for a 64 bit input bfd when the
2914    default is 32 bit.  Also select arch based on apuinfo.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_object_p (bfd *abfd)
2918 {
2919   if (!abfd->arch_info->the_default)
2920     return TRUE;
2921
2922   if (abfd->arch_info->bits_per_word == 32)
2923     {
2924       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927         {
2928           /* Relies on arch after 32 bit default being 64 bit default.  */
2929           abfd->arch_info = abfd->arch_info->next;
2930           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931         }
2932     }
2933   return _bfd_elf_ppc_set_arch (abfd);
2934 }
2935
2936 /* Support for core dump NOTE sections.  */
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   size_t offset, size;
2942
2943   if (note->descsz != 504)
2944     return FALSE;
2945
2946   /* pr_cursig */
2947   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2948
2949   /* pr_pid */
2950   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2951
2952   /* pr_reg */
2953   offset = 112;
2954   size = 384;
2955
2956   /* Make a ".reg/999" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   if (note->descsz != 136)
2965     return FALSE;
2966
2967   elf_tdata (abfd)->core->pid
2968     = bfd_get_32 (abfd, note->descdata + 24);
2969   elf_tdata (abfd)->core->program
2970     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2971   elf_tdata (abfd)->core->command
2972     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974   return TRUE;
2975 }
2976
2977 static char *
2978 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979                            ...)
2980 {
2981   switch (note_type)
2982     {
2983     default:
2984       return NULL;
2985
2986     case NT_PRPSINFO:
2987       {
2988         char data[136];
2989         va_list ap;
2990
2991         va_start (ap, note_type);
2992         memset (data, 0, sizeof (data));
2993         strncpy (data + 40, va_arg (ap, const char *), 16);
2994         strncpy (data + 56, va_arg (ap, const char *), 80);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999
3000     case NT_PRSTATUS:
3001       {
3002         char data[504];
3003         va_list ap;
3004         long pid;
3005         int cursig;
3006         const void *greg;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, 112);
3010         pid = va_arg (ap, long);
3011         bfd_put_32 (abfd, pid, data + 32);
3012         cursig = va_arg (ap, int);
3013         bfd_put_16 (abfd, cursig, data + 12);
3014         greg = va_arg (ap, const void *);
3015         memcpy (data + 112, greg, 384);
3016         memset (data + 496, 0, 8);
3017         va_end (ap);
3018         return elfcore_write_note (abfd, buf, bufsiz,
3019                                    "CORE", note_type, data, sizeof (data));
3020       }
3021     }
3022 }
3023
3024 /* Add extra PPC sections.  */
3025
3026 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 {
3028   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3029   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3034   { NULL,                     0,  0, 0,            0 }
3035 };
3036
3037 enum _ppc64_sec_type {
3038   sec_normal = 0,
3039   sec_opd = 1,
3040   sec_toc = 2
3041 };
3042
3043 struct _ppc64_elf_section_data
3044 {
3045   struct bfd_elf_section_data elf;
3046
3047   union
3048   {
3049     /* An array with one entry for each opd function descriptor,
3050        and some spares since opd entries may be either 16 or 24 bytes.  */
3051 #define OPD_NDX(OFF) ((OFF) >> 4)
3052     struct _opd_sec_data
3053     {
3054       /* Points to the function code section for local opd entries.  */
3055       asection **func_sec;
3056
3057       /* After editing .opd, adjust references to opd local syms.  */
3058       long *adjust;
3059     } opd;
3060
3061     /* An array for toc sections, indexed by offset/8.  */
3062     struct _toc_sec_data
3063     {
3064       /* Specifies the relocation symbol index used at a given toc offset.  */
3065       unsigned *symndx;
3066
3067       /* And the relocation addend.  */
3068       bfd_vma *add;
3069     } toc;
3070   } u;
3071
3072   enum _ppc64_sec_type sec_type:2;
3073
3074   /* Flag set when small branches are detected.  Used to
3075      select suitable defaults for the stub group size.  */
3076   unsigned int has_14bit_branch:1;
3077 };
3078
3079 #define ppc64_elf_section_data(sec) \
3080   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3081
3082 static bfd_boolean
3083 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 {
3085   if (!sec->used_by_bfd)
3086     {
3087       struct _ppc64_elf_section_data *sdata;
3088       bfd_size_type amt = sizeof (*sdata);
3089
3090       sdata = bfd_zalloc (abfd, amt);
3091       if (sdata == NULL)
3092         return FALSE;
3093       sec->used_by_bfd = sdata;
3094     }
3095
3096   return _bfd_elf_new_section_hook (abfd, sec);
3097 }
3098
3099 static struct _opd_sec_data *
3100 get_opd_info (asection * sec)
3101 {
3102   if (sec != NULL
3103       && ppc64_elf_section_data (sec) != NULL
3104       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3105     return &ppc64_elf_section_data (sec)->u.opd;
3106   return NULL;
3107 }
3108 \f
3109 /* Parameters for the qsort hook.  */
3110 static bfd_boolean synthetic_relocatable;
3111 static asection *synthetic_opd;
3112
3113 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3114
3115 static int
3116 compare_symbols (const void *ap, const void *bp)
3117 {
3118   const asymbol *a = * (const asymbol **) ap;
3119   const asymbol *b = * (const asymbol **) bp;
3120
3121   /* Section symbols first.  */
3122   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123     return -1;
3124   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3125     return 1;
3126
3127   /* then .opd symbols.  */
3128   if (synthetic_opd != NULL)
3129     {
3130       if (strcmp (a->section->name, ".opd") == 0
3131           && strcmp (b->section->name, ".opd") != 0)
3132         return -1;
3133       if (strcmp (a->section->name, ".opd") != 0
3134           && strcmp (b->section->name, ".opd") == 0)
3135         return 1;
3136     }
3137
3138   /* then other code symbols.  */
3139   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140       == (SEC_CODE | SEC_ALLOC)
3141       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142          != (SEC_CODE | SEC_ALLOC))
3143     return -1;
3144
3145   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146       != (SEC_CODE | SEC_ALLOC)
3147       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148          == (SEC_CODE | SEC_ALLOC))
3149     return 1;
3150
3151   if (synthetic_relocatable)
3152     {
3153       if (a->section->id < b->section->id)
3154         return -1;
3155
3156       if (a->section->id > b->section->id)
3157         return 1;
3158     }
3159
3160   if (a->value + a->section->vma < b->value + b->section->vma)
3161     return -1;
3162
3163   if (a->value + a->section->vma > b->value + b->section->vma)
3164     return 1;
3165
3166   /* For syms with the same value, prefer strong dynamic global function
3167      syms over other syms.  */
3168   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169     return -1;
3170
3171   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172     return 1;
3173
3174   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175     return -1;
3176
3177   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178     return 1;
3179
3180   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181     return -1;
3182
3183   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184     return 1;
3185
3186   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190     return 1;
3191
3192   return a > b;
3193 }
3194
3195 /* Search SYMS for a symbol of the given VALUE.  */
3196
3197 static asymbol *
3198 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3199 {
3200   long mid;
3201
3202   if (id == (unsigned) -1)
3203     {
3204       while (lo < hi)
3205         {
3206           mid = (lo + hi) >> 1;
3207           if (syms[mid]->value + syms[mid]->section->vma < value)
3208             lo = mid + 1;
3209           else if (syms[mid]->value + syms[mid]->section->vma > value)
3210             hi = mid;
3211           else
3212             return syms[mid];
3213         }
3214     }
3215   else
3216     {
3217       while (lo < hi)
3218         {
3219           mid = (lo + hi) >> 1;
3220           if (syms[mid]->section->id < id)
3221             lo = mid + 1;
3222           else if (syms[mid]->section->id > id)
3223             hi = mid;
3224           else if (syms[mid]->value < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   return NULL;
3233 }
3234
3235 static bfd_boolean
3236 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 {
3238   bfd_vma vma = *(bfd_vma *) ptr;
3239   return ((section->flags & SEC_ALLOC) != 0
3240           && section->vma <= vma
3241           && vma < section->vma + section->size);
3242 }
3243
3244 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3245    entry syms.  Also generate @plt symbols for the glink branch table.
3246    Returns count of synthetic symbols in RET or -1 on error.  */
3247
3248 static long
3249 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250                                 long static_count, asymbol **static_syms,
3251                                 long dyn_count, asymbol **dyn_syms,
3252                                 asymbol **ret)
3253 {
3254   asymbol *s;
3255   long i;
3256   long count;
3257   char *names;
3258   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3259   asection *opd = NULL;
3260   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261   asymbol **syms;
3262   int abi = abiversion (abfd);
3263
3264   *ret = NULL;
3265
3266   if (abi < 2)
3267     {
3268       opd = bfd_get_section_by_name (abfd, ".opd");
3269       if (opd == NULL && abi == 1)
3270         return 0;
3271     }
3272
3273   symcount = static_count;
3274   if (!relocatable)
3275     symcount += dyn_count;
3276   if (symcount == 0)
3277     return 0;
3278
3279   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3280   if (syms == NULL)
3281     return -1;
3282
3283   if (!relocatable && static_count != 0 && dyn_count != 0)
3284     {
3285       /* Use both symbol tables.  */
3286       memcpy (syms, static_syms, static_count * sizeof (*syms));
3287       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288     }
3289   else if (!relocatable && static_count == 0)
3290     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291   else
3292     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293
3294   synthetic_relocatable = relocatable;
3295   synthetic_opd = opd;
3296   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3297
3298   if (!relocatable && symcount > 1)
3299     {
3300       long j;
3301       /* Trim duplicate syms, since we may have merged the normal and
3302          dynamic symbols.  Actually, we only care about syms that have
3303          different values, so trim any with the same value.  */
3304       for (i = 1, j = 1; i < symcount; ++i)
3305         if (syms[i - 1]->value + syms[i - 1]->section->vma
3306             != syms[i]->value + syms[i]->section->vma)
3307           syms[j++] = syms[i];
3308       symcount = j;
3309     }
3310
3311   i = 0;
3312   /* Note that here and in compare_symbols we can't compare opd and
3313      sym->section directly.  With separate debug info files, the
3314      symbols will be extracted from the debug file while abfd passed
3315      to this function is the real binary.  */
3316   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3317     ++i;
3318   codesecsym = i;
3319
3320   for (; i < symcount; ++i)
3321     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3322          != (SEC_CODE | SEC_ALLOC))
3323         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3324       break;
3325   codesecsymend = i;
3326
3327   for (; i < symcount; ++i)
3328     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3329       break;
3330   secsymend = i;
3331
3332   if (opd != NULL)
3333     for (; i < symcount; ++i)
3334       if (strcmp (syms[i]->section->name, ".opd") != 0)
3335         break;
3336   opdsymend = i;
3337
3338   for (; i < symcount; ++i)
3339     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3340         != (SEC_CODE | SEC_ALLOC))
3341       break;
3342   symcount = i;
3343
3344   count = 0;
3345
3346   if (relocatable)
3347     {
3348       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3349       arelent *r;
3350       size_t size;
3351       long relcount;
3352
3353       if (opdsymend == secsymend)
3354         goto done;
3355
3356       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3357       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3358       if (relcount == 0)
3359         goto done;
3360
3361       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3362         {
3363           count = -1;
3364           goto done;
3365         }
3366
3367       size = 0;
3368       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3369         {
3370           asymbol *sym;
3371
3372           while (r < opd->relocation + relcount
3373                  && r->address < syms[i]->value + opd->vma)
3374             ++r;
3375
3376           if (r == opd->relocation + relcount)
3377             break;
3378
3379           if (r->address != syms[i]->value + opd->vma)
3380             continue;
3381
3382           if (r->howto->type != R_PPC64_ADDR64)
3383             continue;
3384
3385           sym = *r->sym_ptr_ptr;
3386           if (!sym_exists_at (syms, opdsymend, symcount,
3387                               sym->section->id, sym->value + r->addend))
3388             {
3389               ++count;
3390               size += sizeof (asymbol);
3391               size += strlen (syms[i]->name) + 2;
3392             }
3393         }
3394
3395       if (size == 0)
3396         goto done;
3397       s = *ret = bfd_malloc (size);
3398       if (s == NULL)
3399         {
3400           count = -1;
3401           goto done;
3402         }
3403
3404       names = (char *) (s + count);
3405
3406       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3407         {
3408           asymbol *sym;
3409
3410           while (r < opd->relocation + relcount
3411                  && r->address < syms[i]->value + opd->vma)
3412             ++r;
3413
3414           if (r == opd->relocation + relcount)
3415             break;
3416
3417           if (r->address != syms[i]->value + opd->vma)
3418             continue;
3419
3420           if (r->howto->type != R_PPC64_ADDR64)
3421             continue;
3422
3423           sym = *r->sym_ptr_ptr;
3424           if (!sym_exists_at (syms, opdsymend, symcount,
3425                               sym->section->id, sym->value + r->addend))
3426             {
3427               size_t len;
3428
3429               *s = *syms[i];
3430               s->flags |= BSF_SYNTHETIC;
3431               s->section = sym->section;
3432               s->value = sym->value + r->addend;
3433               s->name = names;
3434               *names++ = '.';
3435               len = strlen (syms[i]->name);
3436               memcpy (names, syms[i]->name, len + 1);
3437               names += len + 1;
3438               /* Have udata.p point back to the original symbol this
3439                  synthetic symbol was derived from.  */
3440               s->udata.p = syms[i];
3441               s++;
3442             }
3443         }
3444     }
3445   else
3446     {
3447       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3448       bfd_byte *contents = NULL;
3449       size_t size;
3450       long plt_count = 0;
3451       bfd_vma glink_vma = 0, resolv_vma = 0;
3452       asection *dynamic, *glink = NULL, *relplt = NULL;
3453       arelent *p;
3454
3455       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3456         {
3457         free_contents_and_exit_err:
3458           count = -1;
3459         free_contents_and_exit:
3460           if (contents)
3461             free (contents);
3462           goto done;
3463         }
3464
3465       size = 0;
3466       for (i = secsymend; i < opdsymend; ++i)
3467         {
3468           bfd_vma ent;
3469
3470           /* Ignore bogus symbols.  */
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               ++count;
3478               size += sizeof (asymbol);
3479               size += strlen (syms[i]->name) + 2;
3480             }
3481         }
3482
3483       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3484       if (dyn_count != 0
3485           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3486         {
3487           bfd_byte *dynbuf, *extdyn, *extdynend;
3488           size_t extdynsize;
3489           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490
3491           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3492             goto free_contents_and_exit_err;
3493
3494           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3495           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3496
3497           extdyn = dynbuf;
3498           extdynend = extdyn + dynamic->size;
3499           for (; extdyn < extdynend; extdyn += extdynsize)
3500             {
3501               Elf_Internal_Dyn dyn;
3502               (*swap_dyn_in) (abfd, extdyn, &dyn);
3503
3504               if (dyn.d_tag == DT_NULL)
3505                 break;
3506
3507               if (dyn.d_tag == DT_PPC64_GLINK)
3508                 {
3509                   /* The first glink stub starts at offset 32; see
3510                      comment in ppc64_elf_finish_dynamic_sections. */
3511                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3512                   /* The .glink section usually does not survive the final
3513                      link; search for the section (usually .text) where the
3514                      glink stubs now reside.  */
3515                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3516                                                 &glink_vma);
3517                   break;
3518                 }
3519             }
3520
3521           free (dynbuf);
3522         }
3523
3524       if (glink != NULL)
3525         {
3526           /* Determine __glink trampoline by reading the relative branch
3527              from the first glink stub.  */
3528           bfd_byte buf[4];
3529           unsigned int off = 0;
3530
3531           while (bfd_get_section_contents (abfd, glink, buf,
3532                                            glink_vma + off - glink->vma, 4))
3533             {
3534               unsigned int insn = bfd_get_32 (abfd, buf);
3535               insn ^= B_DOT;
3536               if ((insn & ~0x3fffffc) == 0)
3537                 {
3538                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3539                   break;
3540                 }
3541               off += 4;
3542               if (off > 4)
3543                 break;
3544             }
3545
3546           if (resolv_vma)
3547             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3548
3549           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3550           if (relplt != NULL)
3551             {
3552               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3553               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3554                 goto free_contents_and_exit_err;
3555
3556               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3557               size += plt_count * sizeof (asymbol);
3558
3559               p = relplt->relocation;
3560               for (i = 0; i < plt_count; i++, p++)
3561                 {
3562                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563                   if (p->addend != 0)
3564                     size += sizeof ("+0x") - 1 + 16;
3565                 }
3566             }
3567         }
3568
3569       if (size == 0)
3570         goto free_contents_and_exit;
3571       s = *ret = bfd_malloc (size);
3572       if (s == NULL)
3573         goto free_contents_and_exit_err;
3574
3575       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3576
3577       for (i = secsymend; i < opdsymend; ++i)
3578         {
3579           bfd_vma ent;
3580
3581           if (syms[i]->value > opd->size - 8)
3582             continue;
3583
3584           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3585           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3586             {
3587               long lo, hi;
3588               size_t len;
3589               asection *sec = abfd->sections;
3590
3591               *s = *syms[i];
3592               lo = codesecsym;
3593               hi = codesecsymend;
3594               while (lo < hi)
3595                 {
3596                   long mid = (lo + hi) >> 1;
3597                   if (syms[mid]->section->vma < ent)
3598                     lo = mid + 1;
3599                   else if (syms[mid]->section->vma > ent)
3600                     hi = mid;
3601                   else
3602                     {
3603                       sec = syms[mid]->section;
3604                       break;
3605                     }
3606                 }
3607
3608               if (lo >= hi && lo > codesecsym)
3609                 sec = syms[lo - 1]->section;
3610
3611               for (; sec != NULL; sec = sec->next)
3612                 {
3613                   if (sec->vma > ent)
3614                     break;
3615                   /* SEC_LOAD may not be set if SEC is from a separate debug
3616                      info file.  */
3617                   if ((sec->flags & SEC_ALLOC) == 0)
3618                     break;
3619                   if ((sec->flags & SEC_CODE) != 0)
3620                     s->section = sec;
3621                 }
3622               s->flags |= BSF_SYNTHETIC;
3623               s->value = ent - s->section->vma;
3624               s->name = names;
3625               *names++ = '.';
3626               len = strlen (syms[i]->name);
3627               memcpy (names, syms[i]->name, len + 1);
3628               names += len + 1;
3629               /* Have udata.p point back to the original symbol this
3630                  synthetic symbol was derived from.  */
3631               s->udata.p = syms[i];
3632               s++;
3633             }
3634         }
3635       free (contents);
3636
3637       if (glink != NULL && relplt != NULL)
3638         {
3639           if (resolv_vma)
3640             {
3641               /* Add a symbol for the main glink trampoline.  */
3642               memset (s, 0, sizeof *s);
3643               s->the_bfd = abfd;
3644               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3645               s->section = glink;
3646               s->value = resolv_vma - glink->vma;
3647               s->name = names;
3648               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3649               names += sizeof ("__glink_PLTresolve");
3650               s++;
3651               count++;
3652             }
3653
3654           /* FIXME: It would be very much nicer to put sym@plt on the
3655              stub rather than on the glink branch table entry.  The
3656              objdump disassembler would then use a sensible symbol
3657              name on plt calls.  The difficulty in doing so is
3658              a) finding the stubs, and,
3659              b) matching stubs against plt entries, and,
3660              c) there can be multiple stubs for a given plt entry.
3661
3662              Solving (a) could be done by code scanning, but older
3663              ppc64 binaries used different stubs to current code.
3664              (b) is the tricky one since you need to known the toc
3665              pointer for at least one function that uses a pic stub to
3666              be able to calculate the plt address referenced.
3667              (c) means gdb would need to set multiple breakpoints (or
3668              find the glink branch itself) when setting breakpoints
3669              for pending shared library loads.  */
3670           p = relplt->relocation;
3671           for (i = 0; i < plt_count; i++, p++)
3672             {
3673               size_t len;
3674
3675               *s = **p->sym_ptr_ptr;
3676               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3677                  we are defining a symbol, ensure one of them is set.  */
3678               if ((s->flags & BSF_LOCAL) == 0)
3679                 s->flags |= BSF_GLOBAL;
3680               s->flags |= BSF_SYNTHETIC;
3681               s->section = glink;
3682               s->value = glink_vma - glink->vma;
3683               s->name = names;
3684               s->udata.p = NULL;
3685               len = strlen ((*p->sym_ptr_ptr)->name);
3686               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3687               names += len;
3688               if (p->addend != 0)
3689                 {
3690                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3691                   names += sizeof ("+0x") - 1;
3692                   bfd_sprintf_vma (abfd, names, p->addend);
3693                   names += strlen (names);
3694                 }
3695               memcpy (names, "@plt", sizeof ("@plt"));
3696               names += sizeof ("@plt");
3697               s++;
3698               if (abi < 2)
3699                 {
3700                   glink_vma += 8;
3701                   if (i >= 0x8000)
3702                     glink_vma += 4;
3703                 }
3704               else
3705                 glink_vma += 4;
3706             }
3707           count += plt_count;
3708         }
3709     }
3710
3711  done:
3712   free (syms);
3713   return count;
3714 }
3715 \f
3716 /* The following functions are specific to the ELF linker, while
3717    functions above are used generally.  Those named ppc64_elf_* are
3718    called by the main ELF linker code.  They appear in this file more
3719    or less in the order in which they are called.  eg.
3720    ppc64_elf_check_relocs is called early in the link process,
3721    ppc64_elf_finish_dynamic_sections is one of the last functions
3722    called.
3723
3724    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3725    functions have both a function code symbol and a function descriptor
3726    symbol.  A call to foo in a relocatable object file looks like:
3727
3728    .            .text
3729    .    x:
3730    .            bl      .foo
3731    .            nop
3732
3733    The function definition in another object file might be:
3734
3735    .            .section .opd
3736    .    foo:    .quad   .foo
3737    .            .quad   .TOC.@tocbase
3738    .            .quad   0
3739    .
3740    .            .text
3741    .    .foo:   blr
3742
3743    When the linker resolves the call during a static link, the branch
3744    unsurprisingly just goes to .foo and the .opd information is unused.
3745    If the function definition is in a shared library, things are a little
3746    different:  The call goes via a plt call stub, the opd information gets
3747    copied to the plt, and the linker patches the nop.
3748
3749    .    x:
3750    .            bl      .foo_stub
3751    .            ld      2,40(1)
3752    .
3753    .
3754    .    .foo_stub:
3755    .            std     2,40(1)                 # in practice, the call stub
3756    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3757    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3758    .            ld      12,0(11)
3759    .            ld      2,8(11)
3760    .            mtctr   12
3761    .            ld      11,16(11)
3762    .            bctr
3763    .
3764    .            .section .plt
3765    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3766
3767    The "reloc ()" notation is supposed to indicate that the linker emits
3768    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3769    copying.
3770
3771    What are the difficulties here?  Well, firstly, the relocations
3772    examined by the linker in check_relocs are against the function code
3773    sym .foo, while the dynamic relocation in the plt is emitted against
3774    the function descriptor symbol, foo.  Somewhere along the line, we need
3775    to carefully copy dynamic link information from one symbol to the other.
3776    Secondly, the generic part of the elf linker will make .foo a dynamic
3777    symbol as is normal for most other backends.  We need foo dynamic
3778    instead, at least for an application final link.  However, when
3779    creating a shared library containing foo, we need to have both symbols
3780    dynamic so that references to .foo are satisfied during the early
3781    stages of linking.  Otherwise the linker might decide to pull in a
3782    definition from some other object, eg. a static library.
3783
3784    Update: As of August 2004, we support a new convention.  Function
3785    calls may use the function descriptor symbol, ie. "bl foo".  This
3786    behaves exactly as "bl .foo".  */
3787
3788 /* Of those relocs that might be copied as dynamic relocs, this function
3789    selects those that must be copied when linking a shared library,
3790    even when the symbol is local.  */
3791
3792 static int
3793 must_be_dyn_reloc (struct bfd_link_info *info,
3794                    enum elf_ppc64_reloc_type r_type)
3795 {
3796   switch (r_type)
3797     {
3798     default:
3799       return 1;
3800
3801     case R_PPC64_REL32:
3802     case R_PPC64_REL64:
3803     case R_PPC64_REL30:
3804       return 0;
3805
3806     case R_PPC64_TPREL16:
3807     case R_PPC64_TPREL16_LO:
3808     case R_PPC64_TPREL16_HI:
3809     case R_PPC64_TPREL16_HA:
3810     case R_PPC64_TPREL16_DS:
3811     case R_PPC64_TPREL16_LO_DS:
3812     case R_PPC64_TPREL16_HIGH:
3813     case R_PPC64_TPREL16_HIGHA:
3814     case R_PPC64_TPREL16_HIGHER:
3815     case R_PPC64_TPREL16_HIGHERA:
3816     case R_PPC64_TPREL16_HIGHEST:
3817     case R_PPC64_TPREL16_HIGHESTA:
3818     case R_PPC64_TPREL64:
3819       return !bfd_link_executable (info);
3820     }
3821 }
3822
3823 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3824    copying dynamic variables from a shared lib into an app's dynbss
3825    section, and instead use a dynamic relocation to point into the
3826    shared lib.  With code that gcc generates, it's vital that this be
3827    enabled;  In the PowerPC64 ABI, the address of a function is actually
3828    the address of a function descriptor, which resides in the .opd
3829    section.  gcc uses the descriptor directly rather than going via the
3830    GOT as some other ABI's do, which means that initialized function
3831    pointers must reference the descriptor.  Thus, a function pointer
3832    initialized to the address of a function in a shared library will
3833    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3834    redefines the function descriptor symbol to point to the copy.  This
3835    presents a problem as a plt entry for that function is also
3836    initialized from the function descriptor symbol and the copy reloc
3837    may not be initialized first.  */
3838 #define ELIMINATE_COPY_RELOCS 1
3839
3840 /* Section name for stubs is the associated section name plus this
3841    string.  */
3842 #define STUB_SUFFIX ".stub"
3843
3844 /* Linker stubs.
3845    ppc_stub_long_branch:
3846    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3847    destination, but a 24 bit branch in a stub section will reach.
3848    .    b       dest
3849
3850    ppc_stub_plt_branch:
3851    Similar to the above, but a 24 bit branch in the stub section won't
3852    reach its destination.
3853    .    addis   %r11,%r2,xxx@toc@ha
3854    .    ld      %r12,xxx@toc@l(%r11)
3855    .    mtctr   %r12
3856    .    bctr
3857
3858    ppc_stub_plt_call:
3859    Used to call a function in a shared library.  If it so happens that
3860    the plt entry referenced crosses a 64k boundary, then an extra
3861    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3862    .    std     %r2,40(%r1)
3863    .    addis   %r11,%r2,xxx@toc@ha
3864    .    ld      %r12,xxx+0@toc@l(%r11)
3865    .    mtctr   %r12
3866    .    ld      %r2,xxx+8@toc@l(%r11)
3867    .    ld      %r11,xxx+16@toc@l(%r11)
3868    .    bctr
3869
3870    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3871    code to adjust the value and save r2 to support multiple toc sections.
3872    A ppc_stub_long_branch with an r2 offset looks like:
3873    .    std     %r2,40(%r1)
3874    .    addis   %r2,%r2,off@ha
3875    .    addi    %r2,%r2,off@l
3876    .    b       dest
3877
3878    A ppc_stub_plt_branch with an r2 offset looks like:
3879    .    std     %r2,40(%r1)
3880    .    addis   %r11,%r2,xxx@toc@ha
3881    .    ld      %r12,xxx@toc@l(%r11)
3882    .    addis   %r2,%r2,off@ha
3883    .    addi    %r2,%r2,off@l
3884    .    mtctr   %r12
3885    .    bctr
3886
3887    In cases where the "addis" instruction would add zero, the "addis" is
3888    omitted and following instructions modified slightly in some cases.
3889 */
3890
3891 enum ppc_stub_type {
3892   ppc_stub_none,
3893   ppc_stub_long_branch,
3894   ppc_stub_long_branch_r2off,
3895   ppc_stub_plt_branch,
3896   ppc_stub_plt_branch_r2off,
3897   ppc_stub_plt_call,
3898   ppc_stub_plt_call_r2save,
3899   ppc_stub_global_entry,
3900   ppc_stub_save_res
3901 };
3902
3903 /* Information on stub grouping.  */
3904 struct map_stub
3905 {
3906   /* The stub section.  */
3907   asection *stub_sec;
3908   /* This is the section to which stubs in the group will be attached.  */
3909   asection *link_sec;
3910   /* Next group.  */
3911   struct map_stub *next;
3912   /* Whether to emit a copy of register save/restore functions in this
3913      group.  */
3914   int needs_save_res;
3915 };
3916
3917 struct ppc_stub_hash_entry {
3918
3919   /* Base hash table entry structure.  */
3920   struct bfd_hash_entry root;
3921
3922   enum ppc_stub_type stub_type;
3923
3924   /* Group information.  */
3925   struct map_stub *group;
3926
3927   /* Offset within stub_sec of the beginning of this stub.  */
3928   bfd_vma stub_offset;
3929
3930   /* Given the symbol's value and its section we can determine its final
3931      value when building the stubs (so the stub knows where to jump.  */
3932   bfd_vma target_value;
3933   asection *target_section;
3934
3935   /* The symbol table entry, if any, that this was derived from.  */
3936   struct ppc_link_hash_entry *h;
3937   struct plt_entry *plt_ent;
3938
3939   /* Symbol st_other.  */
3940   unsigned char other;
3941 };
3942
3943 struct ppc_branch_hash_entry {
3944
3945   /* Base hash table entry structure.  */
3946   struct bfd_hash_entry root;
3947
3948   /* Offset within branch lookup table.  */
3949   unsigned int offset;
3950
3951   /* Generation marker.  */
3952   unsigned int iter;
3953 };
3954
3955 /* Used to track dynamic relocations for local symbols.  */
3956 struct ppc_dyn_relocs
3957 {
3958   struct ppc_dyn_relocs *next;
3959
3960   /* The input section of the reloc.  */
3961   asection *sec;
3962
3963   /* Total number of relocs copied for the input section.  */
3964   unsigned int count : 31;
3965
3966   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3967   unsigned int ifunc : 1;
3968 };
3969
3970 struct ppc_link_hash_entry
3971 {
3972   struct elf_link_hash_entry elf;
3973
3974   union {
3975     /* A pointer to the most recently used stub hash entry against this
3976        symbol.  */
3977     struct ppc_stub_hash_entry *stub_cache;
3978
3979     /* A pointer to the next symbol starting with a '.'  */
3980     struct ppc_link_hash_entry *next_dot_sym;
3981   } u;
3982
3983   /* Track dynamic relocs copied for this symbol.  */
3984   struct elf_dyn_relocs *dyn_relocs;
3985
3986   /* Chain of aliases referring to a weakdef.  */
3987   struct ppc_link_hash_entry *weakref;
3988
3989   /* Link between function code and descriptor symbols.  */
3990   struct ppc_link_hash_entry *oh;
3991
3992   /* Flag function code and descriptor symbols.  */
3993   unsigned int is_func:1;
3994   unsigned int is_func_descriptor:1;
3995   unsigned int fake:1;
3996
3997   /* Whether global opd/toc sym has been adjusted or not.
3998      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3999      should be set for all globals defined in any opd/toc section.  */
4000   unsigned int adjust_done:1;
4001
4002   /* Set if this is an out-of-line register save/restore function,
4003      with non-standard calling convention.  */
4004   unsigned int save_res:1;
4005
4006   /* Contexts in which symbol is used in the GOT (or TOC).
4007      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4008      corresponding relocs are encountered during check_relocs.
4009      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4010      indicate the corresponding GOT entry type is not needed.
4011      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4012      a TPREL one.  We use a separate flag rather than setting TPREL
4013      just for convenience in distinguishing the two cases.  */
4014 #define TLS_GD           1      /* GD reloc. */
4015 #define TLS_LD           2      /* LD reloc. */
4016 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4017 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4018 #define TLS_TLS         16      /* Any TLS reloc.  */
4019 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4020 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4021 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4022   unsigned char tls_mask;
4023 };
4024
4025 /* ppc64 ELF linker hash table.  */
4026
4027 struct ppc_link_hash_table
4028 {
4029   struct elf_link_hash_table elf;
4030
4031   /* The stub hash table.  */
4032   struct bfd_hash_table stub_hash_table;
4033
4034   /* Another hash table for plt_branch stubs.  */
4035   struct bfd_hash_table branch_hash_table;
4036
4037   /* Hash table for function prologue tocsave.  */
4038   htab_t tocsave_htab;
4039
4040   /* Various options and other info passed from the linker.  */
4041   struct ppc64_elf_params *params;
4042
4043   /* The size of sec_info below.  */
4044   unsigned int sec_info_arr_size;
4045
4046   /* Per-section array of extra section info.  Done this way rather
4047      than as part of ppc64_elf_section_data so we have the info for
4048      non-ppc64 sections.  */
4049   struct
4050   {
4051     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4052     bfd_vma toc_off;
4053
4054     union
4055     {
4056       /* The section group that this section belongs to.  */
4057       struct map_stub *group;
4058       /* A temp section list pointer.  */
4059       asection *list;
4060     } u;
4061   } *sec_info;
4062
4063   /* Linked list of groups.  */
4064   struct map_stub *group;
4065
4066   /* Temp used when calculating TOC pointers.  */
4067   bfd_vma toc_curr;
4068   bfd *toc_bfd;
4069   asection *toc_first_sec;
4070
4071   /* Used when adding symbols.  */
4072   struct ppc_link_hash_entry *dot_syms;
4073
4074   /* Shortcuts to get to dynamic linker sections.  */
4075   asection *glink;
4076   asection *sfpr;
4077   asection *brlt;
4078   asection *relbrlt;
4079   asection *glink_eh_frame;
4080
4081   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4082   struct ppc_link_hash_entry *tls_get_addr;
4083   struct ppc_link_hash_entry *tls_get_addr_fd;
4084
4085   /* The size of reliplt used by got entry relocs.  */
4086   bfd_size_type got_reli_size;
4087
4088   /* Statistics.  */
4089   unsigned long stub_count[ppc_stub_global_entry];
4090
4091   /* Number of stubs against global syms.  */
4092   unsigned long stub_globals;
4093
4094   /* Set if we're linking code with function descriptors.  */
4095   unsigned int opd_abi:1;
4096
4097   /* Support for multiple toc sections.  */
4098   unsigned int do_multi_toc:1;
4099   unsigned int multi_toc_needed:1;
4100   unsigned int second_toc_pass:1;
4101   unsigned int do_toc_opt:1;
4102
4103   /* Set on error.  */
4104   unsigned int stub_error:1;
4105
4106   /* Whether func_desc_adjust needs to be run over symbols.  */
4107   unsigned int need_func_desc_adj:1;
4108
4109   /* Whether there exist local gnu indirect function resolvers,
4110      referenced by dynamic relocations.  */
4111   unsigned int local_ifunc_resolver:1;
4112   unsigned int maybe_local_ifunc_resolver:1;
4113
4114   /* Incremented every time we size stubs.  */
4115   unsigned int stub_iteration;
4116
4117   /* Small local sym cache.  */
4118   struct sym_cache sym_cache;
4119 };
4120
4121 /* Rename some of the generic section flags to better document how they
4122    are used here.  */
4123
4124 /* Nonzero if this section has TLS related relocations.  */
4125 #define has_tls_reloc sec_flg0
4126
4127 /* Nonzero if this section has a call to __tls_get_addr.  */
4128 #define has_tls_get_addr_call sec_flg1
4129
4130 /* Nonzero if this section has any toc or got relocs.  */
4131 #define has_toc_reloc sec_flg2
4132
4133 /* Nonzero if this section has a call to another section that uses
4134    the toc or got.  */
4135 #define makes_toc_func_call sec_flg3
4136
4137 /* Recursion protection when determining above flag.  */
4138 #define call_check_in_progress sec_flg4
4139 #define call_check_done sec_flg5
4140
4141 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4142
4143 #define ppc_hash_table(p) \
4144   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4145   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4146
4147 #define ppc_stub_hash_lookup(table, string, create, copy) \
4148   ((struct ppc_stub_hash_entry *) \
4149    bfd_hash_lookup ((table), (string), (create), (copy)))
4150
4151 #define ppc_branch_hash_lookup(table, string, create, copy) \
4152   ((struct ppc_branch_hash_entry *) \
4153    bfd_hash_lookup ((table), (string), (create), (copy)))
4154
4155 /* Create an entry in the stub hash table.  */
4156
4157 static struct bfd_hash_entry *
4158 stub_hash_newfunc (struct bfd_hash_entry *entry,
4159                    struct bfd_hash_table *table,
4160                    const char *string)
4161 {
4162   /* Allocate the structure if it has not already been allocated by a
4163      subclass.  */
4164   if (entry == NULL)
4165     {
4166       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4167       if (entry == NULL)
4168         return entry;
4169     }
4170
4171   /* Call the allocation method of the superclass.  */
4172   entry = bfd_hash_newfunc (entry, table, string);
4173   if (entry != NULL)
4174     {
4175       struct ppc_stub_hash_entry *eh;
4176
4177       /* Initialize the local fields.  */
4178       eh = (struct ppc_stub_hash_entry *) entry;
4179       eh->stub_type = ppc_stub_none;
4180       eh->group = NULL;
4181       eh->stub_offset = 0;
4182       eh->target_value = 0;
4183       eh->target_section = NULL;
4184       eh->h = NULL;
4185       eh->plt_ent = NULL;
4186       eh->other = 0;
4187     }
4188
4189   return entry;
4190 }
4191
4192 /* Create an entry in the branch hash table.  */
4193
4194 static struct bfd_hash_entry *
4195 branch_hash_newfunc (struct bfd_hash_entry *entry,
4196                      struct bfd_hash_table *table,
4197                      const char *string)
4198 {
4199   /* Allocate the structure if it has not already been allocated by a
4200      subclass.  */
4201   if (entry == NULL)
4202     {
4203       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4204       if (entry == NULL)
4205         return entry;
4206     }
4207
4208   /* Call the allocation method of the superclass.  */
4209   entry = bfd_hash_newfunc (entry, table, string);
4210   if (entry != NULL)
4211     {
4212       struct ppc_branch_hash_entry *eh;
4213
4214       /* Initialize the local fields.  */
4215       eh = (struct ppc_branch_hash_entry *) entry;
4216       eh->offset = 0;
4217       eh->iter = 0;
4218     }
4219
4220   return entry;
4221 }
4222
4223 /* Create an entry in a ppc64 ELF linker hash table.  */
4224
4225 static struct bfd_hash_entry *
4226 link_hash_newfunc (struct bfd_hash_entry *entry,
4227                    struct bfd_hash_table *table,
4228                    const char *string)
4229 {
4230   /* Allocate the structure if it has not already been allocated by a
4231      subclass.  */
4232   if (entry == NULL)
4233     {
4234       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4235       if (entry == NULL)
4236         return entry;
4237     }
4238
4239   /* Call the allocation method of the superclass.  */
4240   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4241   if (entry != NULL)
4242     {
4243       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4244
4245       memset (&eh->u.stub_cache, 0,
4246               (sizeof (struct ppc_link_hash_entry)
4247                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4248
4249       /* When making function calls, old ABI code references function entry
4250          points (dot symbols), while new ABI code references the function
4251          descriptor symbol.  We need to make any combination of reference and
4252          definition work together, without breaking archive linking.
4253
4254          For a defined function "foo" and an undefined call to "bar":
4255          An old object defines "foo" and ".foo", references ".bar" (possibly
4256          "bar" too).
4257          A new object defines "foo" and references "bar".
4258
4259          A new object thus has no problem with its undefined symbols being
4260          satisfied by definitions in an old object.  On the other hand, the
4261          old object won't have ".bar" satisfied by a new object.
4262
4263          Keep a list of newly added dot-symbols.  */
4264
4265       if (string[0] == '.')
4266         {
4267           struct ppc_link_hash_table *htab;
4268
4269           htab = (struct ppc_link_hash_table *) table;
4270           eh->u.next_dot_sym = htab->dot_syms;
4271           htab->dot_syms = eh;
4272         }
4273     }
4274
4275   return entry;
4276 }
4277
4278 struct tocsave_entry {
4279   asection *sec;
4280   bfd_vma offset;
4281 };
4282
4283 static hashval_t
4284 tocsave_htab_hash (const void *p)
4285 {
4286   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4287   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4288 }
4289
4290 static int
4291 tocsave_htab_eq (const void *p1, const void *p2)
4292 {
4293   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4294   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4295   return e1->sec == e2->sec && e1->offset == e2->offset;
4296 }
4297
4298 /* Destroy a ppc64 ELF linker hash table.  */
4299
4300 static void
4301 ppc64_elf_link_hash_table_free (bfd *obfd)
4302 {
4303   struct ppc_link_hash_table *htab;
4304
4305   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4306   if (htab->tocsave_htab)
4307     htab_delete (htab->tocsave_htab);
4308   bfd_hash_table_free (&htab->branch_hash_table);
4309   bfd_hash_table_free (&htab->stub_hash_table);
4310   _bfd_elf_link_hash_table_free (obfd);
4311 }
4312
4313 /* Create a ppc64 ELF linker hash table.  */
4314
4315 static struct bfd_link_hash_table *
4316 ppc64_elf_link_hash_table_create (bfd *abfd)
4317 {
4318   struct ppc_link_hash_table *htab;
4319   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4320
4321   htab = bfd_zmalloc (amt);
4322   if (htab == NULL)
4323     return NULL;
4324
4325   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4326                                       sizeof (struct ppc_link_hash_entry),
4327                                       PPC64_ELF_DATA))
4328     {
4329       free (htab);
4330       return NULL;
4331     }
4332
4333   /* Init the stub hash table too.  */
4334   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4335                             sizeof (struct ppc_stub_hash_entry)))
4336     {
4337       _bfd_elf_link_hash_table_free (abfd);
4338       return NULL;
4339     }
4340
4341   /* And the branch hash table.  */
4342   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4343                             sizeof (struct ppc_branch_hash_entry)))
4344     {
4345       bfd_hash_table_free (&htab->stub_hash_table);
4346       _bfd_elf_link_hash_table_free (abfd);
4347       return NULL;
4348     }
4349
4350   htab->tocsave_htab = htab_try_create (1024,
4351                                         tocsave_htab_hash,
4352                                         tocsave_htab_eq,
4353                                         NULL);
4354   if (htab->tocsave_htab == NULL)
4355     {
4356       ppc64_elf_link_hash_table_free (abfd);
4357       return NULL;
4358     }
4359   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4360
4361   /* Initializing two fields of the union is just cosmetic.  We really
4362      only care about glist, but when compiled on a 32-bit host the
4363      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4364      debugger inspection of these fields look nicer.  */
4365   htab->elf.init_got_refcount.refcount = 0;
4366   htab->elf.init_got_refcount.glist = NULL;
4367   htab->elf.init_plt_refcount.refcount = 0;
4368   htab->elf.init_plt_refcount.glist = NULL;
4369   htab->elf.init_got_offset.offset = 0;
4370   htab->elf.init_got_offset.glist = NULL;
4371   htab->elf.init_plt_offset.offset = 0;
4372   htab->elf.init_plt_offset.glist = NULL;
4373
4374   return &htab->elf.root;
4375 }
4376
4377 /* Create sections for linker generated code.  */
4378
4379 static bfd_boolean
4380 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4381 {
4382   struct ppc_link_hash_table *htab;
4383   flagword flags;
4384
4385   htab = ppc_hash_table (info);
4386
4387   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4388            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4389   if (htab->params->save_restore_funcs)
4390     {
4391       /* Create .sfpr for code to save and restore fp regs.  */
4392       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4393                                                        flags);
4394       if (htab->sfpr == NULL
4395           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4396         return FALSE;
4397     }
4398
4399   if (bfd_link_relocatable (info))
4400     return TRUE;
4401
4402   /* Create .glink for lazy dynamic linking support.  */
4403   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4404                                                     flags);
4405   if (htab->glink == NULL
4406       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4407     return FALSE;
4408
4409   if (!info->no_ld_generated_unwind_info)
4410     {
4411       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4412                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4413       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4414                                                                  ".eh_frame",
4415                                                                  flags);
4416       if (htab->glink_eh_frame == NULL
4417           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4418         return FALSE;
4419     }
4420
4421   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4422   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4423   if (htab->elf.iplt == NULL
4424       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4425     return FALSE;
4426
4427   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4428            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4429   htab->elf.irelplt
4430     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4431   if (htab->elf.irelplt == NULL
4432       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4433     return FALSE;
4434
4435   /* Create branch lookup table for plt_branch stubs.  */
4436   flags = (SEC_ALLOC | SEC_LOAD
4437            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4438   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4439                                                    flags);
4440   if (htab->brlt == NULL
4441       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4442     return FALSE;
4443
4444   if (!bfd_link_pic (info))
4445     return TRUE;
4446
4447   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4448            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4449   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4450                                                       ".rela.branch_lt",
4451                                                       flags);
4452   if (htab->relbrlt == NULL
4453       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4454     return FALSE;
4455
4456   return TRUE;
4457 }
4458
4459 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4460
4461 bfd_boolean
4462 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4463                          struct ppc64_elf_params *params)
4464 {
4465   struct ppc_link_hash_table *htab;
4466
4467   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4468
4469 /* Always hook our dynamic sections into the first bfd, which is the
4470    linker created stub bfd.  This ensures that the GOT header is at
4471    the start of the output TOC section.  */
4472   htab = ppc_hash_table (info);
4473   htab->elf.dynobj = params->stub_bfd;
4474   htab->params = params;
4475
4476   return create_linkage_sections (htab->elf.dynobj, info);
4477 }
4478
4479 /* Build a name for an entry in the stub hash table.  */
4480
4481 static char *
4482 ppc_stub_name (const asection *input_section,
4483                const asection *sym_sec,
4484                const struct ppc_link_hash_entry *h,
4485                const Elf_Internal_Rela *rel)
4486 {
4487   char *stub_name;
4488   ssize_t len;
4489
4490   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4491      offsets from a sym as a branch target?  In fact, we could
4492      probably assume the addend is always zero.  */
4493   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4494
4495   if (h)
4496     {
4497       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4498       stub_name = bfd_malloc (len);
4499       if (stub_name == NULL)
4500         return stub_name;
4501
4502       len = sprintf (stub_name, "%08x.%s+%x",
4503                      input_section->id & 0xffffffff,
4504                      h->elf.root.root.string,
4505                      (int) rel->r_addend & 0xffffffff);
4506     }
4507   else
4508     {
4509       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4510       stub_name = bfd_malloc (len);
4511       if (stub_name == NULL)
4512         return stub_name;
4513
4514       len = sprintf (stub_name, "%08x.%x:%x+%x",
4515                      input_section->id & 0xffffffff,
4516                      sym_sec->id & 0xffffffff,
4517                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4518                      (int) rel->r_addend & 0xffffffff);
4519     }
4520   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4521     stub_name[len - 2] = 0;
4522   return stub_name;
4523 }
4524
4525 /* Look up an entry in the stub hash.  Stub entries are cached because
4526    creating the stub name takes a bit of time.  */
4527
4528 static struct ppc_stub_hash_entry *
4529 ppc_get_stub_entry (const asection *input_section,
4530                     const asection *sym_sec,
4531                     struct ppc_link_hash_entry *h,
4532                     const Elf_Internal_Rela *rel,
4533                     struct ppc_link_hash_table *htab)
4534 {
4535   struct ppc_stub_hash_entry *stub_entry;
4536   struct map_stub *group;
4537
4538   /* If this input section is part of a group of sections sharing one
4539      stub section, then use the id of the first section in the group.
4540      Stub names need to include a section id, as there may well be
4541      more than one stub used to reach say, printf, and we need to
4542      distinguish between them.  */
4543   group = htab->sec_info[input_section->id].u.group;
4544   if (group == NULL)
4545     return NULL;
4546
4547   if (h != NULL && h->u.stub_cache != NULL
4548       && h->u.stub_cache->h == h
4549       && h->u.stub_cache->group == group)
4550     {
4551       stub_entry = h->u.stub_cache;
4552     }
4553   else
4554     {
4555       char *stub_name;
4556
4557       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4558       if (stub_name == NULL)
4559         return NULL;
4560
4561       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4562                                          stub_name, FALSE, FALSE);
4563       if (h != NULL)
4564         h->u.stub_cache = stub_entry;
4565
4566       free (stub_name);
4567     }
4568
4569   return stub_entry;
4570 }
4571
4572 /* Add a new stub entry to the stub hash.  Not all fields of the new
4573    stub entry are initialised.  */
4574
4575 static struct ppc_stub_hash_entry *
4576 ppc_add_stub (const char *stub_name,
4577               asection *section,
4578               struct bfd_link_info *info)
4579 {
4580   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4581   struct map_stub *group;
4582   asection *link_sec;
4583   asection *stub_sec;
4584   struct ppc_stub_hash_entry *stub_entry;
4585
4586   group = htab->sec_info[section->id].u.group;
4587   link_sec = group->link_sec;
4588   stub_sec = group->stub_sec;
4589   if (stub_sec == NULL)
4590     {
4591       size_t namelen;
4592       bfd_size_type len;
4593       char *s_name;
4594
4595       namelen = strlen (link_sec->name);
4596       len = namelen + sizeof (STUB_SUFFIX);
4597       s_name = bfd_alloc (htab->params->stub_bfd, len);
4598       if (s_name == NULL)
4599         return NULL;
4600
4601       memcpy (s_name, link_sec->name, namelen);
4602       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4603       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4604       if (stub_sec == NULL)
4605         return NULL;
4606       group->stub_sec = stub_sec;
4607     }
4608
4609   /* Enter this entry into the linker stub hash table.  */
4610   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4611                                      TRUE, FALSE);
4612   if (stub_entry == NULL)
4613     {
4614       /* xgettext:c-format */
4615       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4616                               section->owner, stub_name);
4617       return NULL;
4618     }
4619
4620   stub_entry->group = group;
4621   stub_entry->stub_offset = 0;
4622   return stub_entry;
4623 }
4624
4625 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4626    not already done.  */
4627
4628 static bfd_boolean
4629 create_got_section (bfd *abfd, struct bfd_link_info *info)
4630 {
4631   asection *got, *relgot;
4632   flagword flags;
4633   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4634
4635   if (!is_ppc64_elf (abfd))
4636     return FALSE;
4637   if (htab == NULL)
4638     return FALSE;
4639
4640   if (!htab->elf.sgot
4641       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4642     return FALSE;
4643
4644   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4645            | SEC_LINKER_CREATED);
4646
4647   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4648   if (!got
4649       || !bfd_set_section_alignment (abfd, got, 3))
4650     return FALSE;
4651
4652   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4653                                                flags | SEC_READONLY);
4654   if (!relgot
4655       || ! bfd_set_section_alignment (abfd, relgot, 3))
4656     return FALSE;
4657
4658   ppc64_elf_tdata (abfd)->got = got;
4659   ppc64_elf_tdata (abfd)->relgot = relgot;
4660   return TRUE;
4661 }
4662
4663 /* Follow indirect and warning symbol links.  */
4664
4665 static inline struct bfd_link_hash_entry *
4666 follow_link (struct bfd_link_hash_entry *h)
4667 {
4668   while (h->type == bfd_link_hash_indirect
4669          || h->type == bfd_link_hash_warning)
4670     h = h->u.i.link;
4671   return h;
4672 }
4673
4674 static inline struct elf_link_hash_entry *
4675 elf_follow_link (struct elf_link_hash_entry *h)
4676 {
4677   return (struct elf_link_hash_entry *) follow_link (&h->root);
4678 }
4679
4680 static inline struct ppc_link_hash_entry *
4681 ppc_follow_link (struct ppc_link_hash_entry *h)
4682 {
4683   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4684 }
4685
4686 /* Merge PLT info on FROM with that on TO.  */
4687
4688 static void
4689 move_plt_plist (struct ppc_link_hash_entry *from,
4690                 struct ppc_link_hash_entry *to)
4691 {
4692   if (from->elf.plt.plist != NULL)
4693     {
4694       if (to->elf.plt.plist != NULL)
4695         {
4696           struct plt_entry **entp;
4697           struct plt_entry *ent;
4698
4699           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4700             {
4701               struct plt_entry *dent;
4702
4703               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4704                 if (dent->addend == ent->addend)
4705                   {
4706                     dent->plt.refcount += ent->plt.refcount;
4707                     *entp = ent->next;
4708                     break;
4709                   }
4710               if (dent == NULL)
4711                 entp = &ent->next;
4712             }
4713           *entp = to->elf.plt.plist;
4714         }
4715
4716       to->elf.plt.plist = from->elf.plt.plist;
4717       from->elf.plt.plist = NULL;
4718     }
4719 }
4720
4721 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4722
4723 static void
4724 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4725                                 struct elf_link_hash_entry *dir,
4726                                 struct elf_link_hash_entry *ind)
4727 {
4728   struct ppc_link_hash_entry *edir, *eind;
4729
4730   edir = (struct ppc_link_hash_entry *) dir;
4731   eind = (struct ppc_link_hash_entry *) ind;
4732
4733   edir->is_func |= eind->is_func;
4734   edir->is_func_descriptor |= eind->is_func_descriptor;
4735   edir->tls_mask |= eind->tls_mask;
4736   if (eind->oh != NULL)
4737     edir->oh = ppc_follow_link (eind->oh);
4738
4739   /* If called to transfer flags for a weakdef during processing
4740      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4741      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4742   if (!(ELIMINATE_COPY_RELOCS
4743         && eind->elf.root.type != bfd_link_hash_indirect
4744         && edir->elf.dynamic_adjusted))
4745     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4746
4747   if (edir->elf.versioned != versioned_hidden)
4748     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4749   edir->elf.ref_regular |= eind->elf.ref_regular;
4750   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4751   edir->elf.needs_plt |= eind->elf.needs_plt;
4752   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4753
4754   /* If we were called to copy over info for a weak sym, don't copy
4755      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4756      in order to simplify readonly_dynrelocs and save a field in the
4757      symbol hash entry, but that means dyn_relocs can't be used in any
4758      tests about a specific symbol, or affect other symbol flags which
4759      are then tested.
4760      Chain weakdefs so we can get from the weakdef back to an alias.
4761      The list is circular so that we don't need to use u.weakdef as
4762      well as this list to look at all aliases.  */
4763   if (eind->elf.root.type != bfd_link_hash_indirect)
4764     {
4765       struct ppc_link_hash_entry *cur, *add, *next;
4766
4767       add = eind;
4768       do
4769         {
4770           cur = edir->weakref;
4771           if (cur != NULL)
4772             {
4773               do
4774                 {
4775                   /* We can be called twice for the same symbols.
4776                      Don't make multiple loops.  */
4777                   if (cur == add)
4778                     return;
4779                   cur = cur->weakref;
4780                 } while (cur != edir);
4781             }
4782           next = add->weakref;
4783           if (cur != add)
4784             {
4785               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4786               edir->weakref = add;
4787             }
4788           add = next;
4789         } while (add != NULL && add != eind);
4790       return;
4791     }
4792
4793   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4794   if (eind->dyn_relocs != NULL)
4795     {
4796       if (edir->dyn_relocs != NULL)
4797         {
4798           struct elf_dyn_relocs **pp;
4799           struct elf_dyn_relocs *p;
4800
4801           /* Add reloc counts against the indirect sym to the direct sym
4802              list.  Merge any entries against the same section.  */
4803           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4804             {
4805               struct elf_dyn_relocs *q;
4806
4807               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4808                 if (q->sec == p->sec)
4809                   {
4810                     q->pc_count += p->pc_count;
4811                     q->count += p->count;
4812                     *pp = p->next;
4813                     break;
4814                   }
4815               if (q == NULL)
4816                 pp = &p->next;
4817             }
4818           *pp = edir->dyn_relocs;
4819         }
4820
4821       edir->dyn_relocs = eind->dyn_relocs;
4822       eind->dyn_relocs = NULL;
4823     }
4824
4825   /* Copy over got entries that we may have already seen to the
4826      symbol which just became indirect.  */
4827   if (eind->elf.got.glist != NULL)
4828     {
4829       if (edir->elf.got.glist != NULL)
4830         {
4831           struct got_entry **entp;
4832           struct got_entry *ent;
4833
4834           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4835             {
4836               struct got_entry *dent;
4837
4838               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4839                 if (dent->addend == ent->addend
4840                     && dent->owner == ent->owner
4841                     && dent->tls_type == ent->tls_type)
4842                   {
4843                     dent->got.refcount += ent->got.refcount;
4844                     *entp = ent->next;
4845                     break;
4846                   }
4847               if (dent == NULL)
4848                 entp = &ent->next;
4849             }
4850           *entp = edir->elf.got.glist;
4851         }
4852
4853       edir->elf.got.glist = eind->elf.got.glist;
4854       eind->elf.got.glist = NULL;
4855     }
4856
4857   /* And plt entries.  */
4858   move_plt_plist (eind, edir);
4859
4860   if (eind->elf.dynindx != -1)
4861     {
4862       if (edir->elf.dynindx != -1)
4863         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4864                                 edir->elf.dynstr_index);
4865       edir->elf.dynindx = eind->elf.dynindx;
4866       edir->elf.dynstr_index = eind->elf.dynstr_index;
4867       eind->elf.dynindx = -1;
4868       eind->elf.dynstr_index = 0;
4869     }
4870 }
4871
4872 /* Find the function descriptor hash entry from the given function code
4873    hash entry FH.  Link the entries via their OH fields.  */
4874
4875 static struct ppc_link_hash_entry *
4876 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4877 {
4878   struct ppc_link_hash_entry *fdh = fh->oh;
4879
4880   if (fdh == NULL)
4881     {
4882       const char *fd_name = fh->elf.root.root.string + 1;
4883
4884       fdh = (struct ppc_link_hash_entry *)
4885         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4886       if (fdh == NULL)
4887         return fdh;
4888
4889       fdh->is_func_descriptor = 1;
4890       fdh->oh = fh;
4891       fh->is_func = 1;
4892       fh->oh = fdh;
4893     }
4894
4895   fdh = ppc_follow_link (fdh);
4896   fdh->is_func_descriptor = 1;
4897   fdh->oh = fh;
4898   return fdh;
4899 }
4900
4901 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4902
4903 static struct ppc_link_hash_entry *
4904 make_fdh (struct bfd_link_info *info,
4905           struct ppc_link_hash_entry *fh)
4906 {
4907   bfd *abfd = fh->elf.root.u.undef.abfd;
4908   struct bfd_link_hash_entry *bh = NULL;
4909   struct ppc_link_hash_entry *fdh;
4910   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4911                     ? BSF_WEAK
4912                     : BSF_GLOBAL);
4913
4914   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4915                                          fh->elf.root.root.string + 1,
4916                                          flags, bfd_und_section_ptr, 0,
4917                                          NULL, FALSE, FALSE, &bh))
4918     return NULL;
4919
4920   fdh = (struct ppc_link_hash_entry *) bh;
4921   fdh->elf.non_elf = 0;
4922   fdh->fake = 1;
4923   fdh->is_func_descriptor = 1;
4924   fdh->oh = fh;
4925   fh->is_func = 1;
4926   fh->oh = fdh;
4927   return fdh;
4928 }
4929
4930 /* Fix function descriptor symbols defined in .opd sections to be
4931    function type.  */
4932
4933 static bfd_boolean
4934 ppc64_elf_add_symbol_hook (bfd *ibfd,
4935                            struct bfd_link_info *info,
4936                            Elf_Internal_Sym *isym,
4937                            const char **name,
4938                            flagword *flags ATTRIBUTE_UNUSED,
4939                            asection **sec,
4940                            bfd_vma *value)
4941 {
4942   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4943       && (ibfd->flags & DYNAMIC) == 0
4944       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4945     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4946
4947   if (*sec != NULL
4948       && strcmp ((*sec)->name, ".opd") == 0)
4949     {
4950       asection *code_sec;
4951
4952       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4953             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4954         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4955
4956       /* If the symbol is a function defined in .opd, and the function
4957          code is in a discarded group, let it appear to be undefined.  */
4958       if (!bfd_link_relocatable (info)
4959           && (*sec)->reloc_count != 0
4960           && opd_entry_value (*sec, *value, &code_sec, NULL,
4961                               FALSE) != (bfd_vma) -1
4962           && discarded_section (code_sec))
4963         {
4964           *sec = bfd_und_section_ptr;
4965           isym->st_shndx = SHN_UNDEF;
4966         }
4967     }
4968   else if (*sec != NULL
4969            && strcmp ((*sec)->name, ".toc") == 0
4970            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4971     {
4972       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4973       if (htab != NULL)
4974         htab->params->object_in_toc = 1;
4975     }
4976
4977   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4978     {
4979       if (abiversion (ibfd) == 0)
4980         set_abiversion (ibfd, 2);
4981       else if (abiversion (ibfd) == 1)
4982         {
4983           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4984                                     " for ABI version 1\n"), name);
4985           bfd_set_error (bfd_error_bad_value);
4986           return FALSE;
4987         }
4988     }
4989
4990   return TRUE;
4991 }
4992
4993 /* Merge non-visibility st_other attributes: local entry point.  */
4994
4995 static void
4996 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4997                                   const Elf_Internal_Sym *isym,
4998                                   bfd_boolean definition,
4999                                   bfd_boolean dynamic)
5000 {
5001   if (definition && !dynamic)
5002     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5003                 | ELF_ST_VISIBILITY (h->other));
5004 }
5005
5006 /* Hook called on merging a symbol.  We use this to clear "fake" since
5007    we now have a real symbol.  */
5008
5009 static bfd_boolean
5010 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5011                         const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5012                         asection **psec ATTRIBUTE_UNUSED,
5013                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5014                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5015                         bfd *oldbfd ATTRIBUTE_UNUSED,
5016                         const asection *oldsec ATTRIBUTE_UNUSED)
5017 {
5018   ((struct ppc_link_hash_entry *) h)->fake = 0;
5019   return TRUE;
5020 }
5021
5022 /* This function makes an old ABI object reference to ".bar" cause the
5023    inclusion of a new ABI object archive that defines "bar".
5024    NAME is a symbol defined in an archive.  Return a symbol in the hash
5025    table that might be satisfied by the archive symbols.  */
5026
5027 static struct elf_link_hash_entry *
5028 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5029                                  struct bfd_link_info *info,
5030                                  const char *name)
5031 {
5032   struct elf_link_hash_entry *h;
5033   char *dot_name;
5034   size_t len;
5035
5036   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5037   if (h != NULL
5038       /* Don't return this sym if it is a fake function descriptor
5039          created by add_symbol_adjust.  */
5040       && !((struct ppc_link_hash_entry *) h)->fake)
5041     return h;
5042
5043   if (name[0] == '.')
5044     return h;
5045
5046   len = strlen (name);
5047   dot_name = bfd_alloc (abfd, len + 2);
5048   if (dot_name == NULL)
5049     return (struct elf_link_hash_entry *) 0 - 1;
5050   dot_name[0] = '.';
5051   memcpy (dot_name + 1, name, len + 1);
5052   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5053   bfd_release (abfd, dot_name);
5054   return h;
5055 }
5056
5057 /* This function satisfies all old ABI object references to ".bar" if a
5058    new ABI object defines "bar".  Well, at least, undefined dot symbols
5059    are made weak.  This stops later archive searches from including an
5060    object if we already have a function descriptor definition.  It also
5061    prevents the linker complaining about undefined symbols.
5062    We also check and correct mismatched symbol visibility here.  The
5063    most restrictive visibility of the function descriptor and the
5064    function entry symbol is used.  */
5065
5066 static bfd_boolean
5067 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5068 {
5069   struct ppc_link_hash_table *htab;
5070   struct ppc_link_hash_entry *fdh;
5071
5072   if (eh->elf.root.type == bfd_link_hash_warning)
5073     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5074
5075   if (eh->elf.root.type == bfd_link_hash_indirect)
5076     return TRUE;
5077
5078   if (eh->elf.root.root.string[0] != '.')
5079     abort ();
5080
5081   htab = ppc_hash_table (info);
5082   if (htab == NULL)
5083     return FALSE;
5084
5085   fdh = lookup_fdh (eh, htab);
5086   if (fdh == NULL
5087       && !bfd_link_relocatable (info)
5088       && (eh->elf.root.type == bfd_link_hash_undefined
5089           || eh->elf.root.type == bfd_link_hash_undefweak)
5090       && eh->elf.ref_regular)
5091     {
5092       /* Make an undefined function descriptor sym, in order to
5093          pull in an --as-needed shared lib.  Archives are handled
5094          elsewhere.  */
5095       fdh = make_fdh (info, eh);
5096       if (fdh == NULL)
5097         return FALSE;
5098     }
5099
5100   if (fdh != NULL)
5101     {
5102       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5103       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5104
5105       /* Make both descriptor and entry symbol have the most
5106          constraining visibility of either symbol.  */
5107       if (entry_vis < descr_vis)
5108         fdh->elf.other += entry_vis - descr_vis;
5109       else if (entry_vis > descr_vis)
5110         eh->elf.other += descr_vis - entry_vis;
5111
5112       /* Propagate reference flags from entry symbol to function
5113          descriptor symbol.  */
5114       fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5115       fdh->elf.ref_regular |= eh->elf.ref_regular;
5116       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5117
5118       if (!fdh->elf.forced_local
5119           && fdh->elf.dynindx == -1
5120           && fdh->elf.versioned != versioned_hidden
5121           && (bfd_link_dll (info)
5122               || fdh->elf.def_dynamic
5123               || fdh->elf.ref_dynamic)
5124           && (eh->elf.ref_regular
5125               || eh->elf.def_regular))
5126         {
5127           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5128             return FALSE;
5129         }
5130     }
5131
5132   return TRUE;
5133 }
5134
5135 /* Set up opd section info and abiversion for IBFD, and process list
5136    of dot-symbols we made in link_hash_newfunc.  */
5137
5138 static bfd_boolean
5139 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5140 {
5141   struct ppc_link_hash_table *htab;
5142   struct ppc_link_hash_entry **p, *eh;
5143   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5144
5145   if (opd != NULL && opd->size != 0)
5146     {
5147       if (abiversion (ibfd) == 0)
5148         set_abiversion (ibfd, 1);
5149       else if (abiversion (ibfd) >= 2)
5150         {
5151           /* xgettext:c-format */
5152           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5153                                     " version %d\n"),
5154                                   ibfd, abiversion (ibfd));
5155           bfd_set_error (bfd_error_bad_value);
5156           return FALSE;
5157         }
5158
5159       if ((ibfd->flags & DYNAMIC) == 0
5160           && (opd->flags & SEC_RELOC) != 0
5161           && opd->reloc_count != 0
5162           && !bfd_is_abs_section (opd->output_section))
5163         {
5164           /* Garbage collection needs some extra help with .opd sections.
5165              We don't want to necessarily keep everything referenced by
5166              relocs in .opd, as that would keep all functions.  Instead,
5167              if we reference an .opd symbol (a function descriptor), we
5168              want to keep the function code symbol's section.  This is
5169              easy for global symbols, but for local syms we need to keep
5170              information about the associated function section.  */
5171           bfd_size_type amt;
5172           asection **opd_sym_map;
5173
5174           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5175           opd_sym_map = bfd_zalloc (ibfd, amt);
5176           if (opd_sym_map == NULL)
5177             return FALSE;
5178           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5179           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5180           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5181         }
5182     }
5183
5184   if (!is_ppc64_elf (info->output_bfd))
5185     return TRUE;
5186   htab = ppc_hash_table (info);
5187   if (htab == NULL)
5188     return FALSE;
5189
5190   /* For input files without an explicit abiversion in e_flags
5191      we should have flagged any with symbol st_other bits set
5192      as ELFv1 and above flagged those with .opd as ELFv2.
5193      Set the output abiversion if not yet set, and for any input
5194      still ambiguous, take its abiversion from the output.
5195      Differences in ABI are reported later.  */
5196   if (abiversion (info->output_bfd) == 0)
5197     set_abiversion (info->output_bfd, abiversion (ibfd));
5198   else if (abiversion (ibfd) == 0)
5199     set_abiversion (ibfd, abiversion (info->output_bfd));
5200
5201   p = &htab->dot_syms;
5202   while ((eh = *p) != NULL)
5203     {
5204       *p = NULL;
5205       if (&eh->elf == htab->elf.hgot)
5206         ;
5207       else if (htab->elf.hgot == NULL
5208                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5209         htab->elf.hgot = &eh->elf;
5210       else if (abiversion (ibfd) <= 1)
5211         {
5212           htab->need_func_desc_adj = 1;
5213           if (!add_symbol_adjust (eh, info))
5214             return FALSE;
5215         }
5216       p = &eh->u.next_dot_sym;
5217     }
5218   return TRUE;
5219 }
5220
5221 /* Undo hash table changes when an --as-needed input file is determined
5222    not to be needed.  */
5223
5224 static bfd_boolean
5225 ppc64_elf_notice_as_needed (bfd *ibfd,
5226                             struct bfd_link_info *info,
5227                             enum notice_asneeded_action act)
5228 {
5229   if (act == notice_not_needed)
5230     {
5231       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5232
5233       if (htab == NULL)
5234         return FALSE;
5235
5236       htab->dot_syms = NULL;
5237     }
5238   return _bfd_elf_notice_as_needed (ibfd, info, act);
5239 }
5240
5241 /* If --just-symbols against a final linked binary, then assume we need
5242    toc adjusting stubs when calling functions defined there.  */
5243
5244 static void
5245 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5246 {
5247   if ((sec->flags & SEC_CODE) != 0
5248       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5249       && is_ppc64_elf (sec->owner))
5250     {
5251       if (abiversion (sec->owner) >= 2
5252           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5253         sec->has_toc_reloc = 1;
5254     }
5255   _bfd_elf_link_just_syms (sec, info);
5256 }
5257
5258 static struct plt_entry **
5259 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5260                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5261 {
5262   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5263   struct plt_entry **local_plt;
5264   unsigned char *local_got_tls_masks;
5265
5266   if (local_got_ents == NULL)
5267     {
5268       bfd_size_type size = symtab_hdr->sh_info;
5269
5270       size *= (sizeof (*local_got_ents)
5271                + sizeof (*local_plt)
5272                + sizeof (*local_got_tls_masks));
5273       local_got_ents = bfd_zalloc (abfd, size);
5274       if (local_got_ents == NULL)
5275         return NULL;
5276       elf_local_got_ents (abfd) = local_got_ents;
5277     }
5278
5279   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5280     {
5281       struct got_entry *ent;
5282
5283       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5284         if (ent->addend == r_addend
5285             && ent->owner == abfd
5286             && ent->tls_type == tls_type)
5287           break;
5288       if (ent == NULL)
5289         {
5290           bfd_size_type amt = sizeof (*ent);
5291           ent = bfd_alloc (abfd, amt);
5292           if (ent == NULL)
5293             return FALSE;
5294           ent->next = local_got_ents[r_symndx];
5295           ent->addend = r_addend;
5296           ent->owner = abfd;
5297           ent->tls_type = tls_type;
5298           ent->is_indirect = FALSE;
5299           ent->got.refcount = 0;
5300           local_got_ents[r_symndx] = ent;
5301         }
5302       ent->got.refcount += 1;
5303     }
5304
5305   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5306   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5307   local_got_tls_masks[r_symndx] |= tls_type;
5308
5309   return local_plt + r_symndx;
5310 }
5311
5312 static bfd_boolean
5313 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5314 {
5315   struct plt_entry *ent;
5316
5317   for (ent = *plist; ent != NULL; ent = ent->next)
5318     if (ent->addend == addend)
5319       break;
5320   if (ent == NULL)
5321     {
5322       bfd_size_type amt = sizeof (*ent);
5323       ent = bfd_alloc (abfd, amt);
5324       if (ent == NULL)
5325         return FALSE;
5326       ent->next = *plist;
5327       ent->addend = addend;
5328       ent->plt.refcount = 0;
5329       *plist = ent;
5330     }
5331   ent->plt.refcount += 1;
5332   return TRUE;
5333 }
5334
5335 static bfd_boolean
5336 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5337 {
5338   return (r_type == R_PPC64_REL24
5339           || r_type == R_PPC64_REL14
5340           || r_type == R_PPC64_REL14_BRTAKEN
5341           || r_type == R_PPC64_REL14_BRNTAKEN
5342           || r_type == R_PPC64_ADDR24
5343           || r_type == R_PPC64_ADDR14
5344           || r_type == R_PPC64_ADDR14_BRTAKEN
5345           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5346 }
5347
5348 /* Look through the relocs for a section during the first phase, and
5349    calculate needed space in the global offset table, procedure
5350    linkage table, and dynamic reloc sections.  */
5351
5352 static bfd_boolean
5353 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5354                         asection *sec, const Elf_Internal_Rela *relocs)
5355 {
5356   struct ppc_link_hash_table *htab;
5357   Elf_Internal_Shdr *symtab_hdr;
5358   struct elf_link_hash_entry **sym_hashes;
5359   const Elf_Internal_Rela *rel;
5360   const Elf_Internal_Rela *rel_end;
5361   asection *sreloc;
5362   asection **opd_sym_map;
5363   struct elf_link_hash_entry *tga, *dottga;
5364
5365   if (bfd_link_relocatable (info))
5366     return TRUE;
5367
5368   /* Don't do anything special with non-loaded, non-alloced sections.
5369      In particular, any relocs in such sections should not affect GOT
5370      and PLT reference counting (ie. we don't allow them to create GOT
5371      or PLT entries), there's no possibility or desire to optimize TLS
5372      relocs, and there's not much point in propagating relocs to shared
5373      libs that the dynamic linker won't relocate.  */
5374   if ((sec->flags & SEC_ALLOC) == 0)
5375     return TRUE;
5376
5377   BFD_ASSERT (is_ppc64_elf (abfd));
5378
5379   htab = ppc_hash_table (info);
5380   if (htab == NULL)
5381     return FALSE;
5382
5383   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5384                               FALSE, FALSE, TRUE);
5385   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5386                                  FALSE, FALSE, TRUE);
5387   symtab_hdr = &elf_symtab_hdr (abfd);
5388   sym_hashes = elf_sym_hashes (abfd);
5389   sreloc = NULL;
5390   opd_sym_map = NULL;
5391   if (ppc64_elf_section_data (sec) != NULL
5392       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5393     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5394
5395   rel_end = relocs + sec->reloc_count;
5396   for (rel = relocs; rel < rel_end; rel++)
5397     {
5398       unsigned long r_symndx;
5399       struct elf_link_hash_entry *h;
5400       enum elf_ppc64_reloc_type r_type;
5401       int tls_type;
5402       struct _ppc64_elf_section_data *ppc64_sec;
5403       struct plt_entry **ifunc, **plt_list;
5404
5405       r_symndx = ELF64_R_SYM (rel->r_info);
5406       if (r_symndx < symtab_hdr->sh_info)
5407         h = NULL;
5408       else
5409         {
5410           struct ppc_link_hash_entry *eh;
5411
5412           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5413           h = elf_follow_link (h);
5414           eh = (struct ppc_link_hash_entry *) h;
5415
5416           /* PR15323, ref flags aren't set for references in the same
5417              object.  */
5418           h->root.non_ir_ref = 1;
5419           if (eh->is_func && eh->oh != NULL)
5420             eh->oh->elf.root.non_ir_ref = 1;
5421
5422           if (h == htab->elf.hgot)
5423             sec->has_toc_reloc = 1;
5424         }
5425
5426       tls_type = 0;
5427       ifunc = NULL;
5428       if (h != NULL)
5429         {
5430           if (h->type == STT_GNU_IFUNC)
5431             {
5432               h->needs_plt = 1;
5433               ifunc = &h->plt.plist;
5434             }
5435         }
5436       else
5437         {
5438           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5439                                                           abfd, r_symndx);
5440           if (isym == NULL)
5441             return FALSE;
5442
5443           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5444             {
5445               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5446                                              rel->r_addend, PLT_IFUNC);
5447               if (ifunc == NULL)
5448                 return FALSE;
5449             }
5450         }
5451
5452       r_type = ELF64_R_TYPE (rel->r_info);
5453       switch (r_type)
5454         {
5455         case R_PPC64_TLSGD:
5456         case R_PPC64_TLSLD:
5457           /* These special tls relocs tie a call to __tls_get_addr with
5458              its parameter symbol.  */
5459           break;
5460
5461         case R_PPC64_GOT_TLSLD16:
5462         case R_PPC64_GOT_TLSLD16_LO:
5463         case R_PPC64_GOT_TLSLD16_HI:
5464         case R_PPC64_GOT_TLSLD16_HA:
5465           tls_type = TLS_TLS | TLS_LD;
5466           goto dogottls;
5467
5468         case R_PPC64_GOT_TLSGD16:
5469         case R_PPC64_GOT_TLSGD16_LO:
5470         case R_PPC64_GOT_TLSGD16_HI:
5471         case R_PPC64_GOT_TLSGD16_HA:
5472           tls_type = TLS_TLS | TLS_GD;
5473           goto dogottls;
5474
5475         case R_PPC64_GOT_TPREL16_DS:
5476         case R_PPC64_GOT_TPREL16_LO_DS:
5477         case R_PPC64_GOT_TPREL16_HI:
5478         case R_PPC64_GOT_TPREL16_HA:
5479           if (bfd_link_pic (info))
5480             info->flags |= DF_STATIC_TLS;
5481           tls_type = TLS_TLS | TLS_TPREL;
5482           goto dogottls;
5483
5484         case R_PPC64_GOT_DTPREL16_DS:
5485         case R_PPC64_GOT_DTPREL16_LO_DS:
5486         case R_PPC64_GOT_DTPREL16_HI:
5487         case R_PPC64_GOT_DTPREL16_HA:
5488           tls_type = TLS_TLS | TLS_DTPREL;
5489         dogottls:
5490           sec->has_tls_reloc = 1;
5491           /* Fall through */
5492
5493         case R_PPC64_GOT16:
5494         case R_PPC64_GOT16_DS:
5495         case R_PPC64_GOT16_HA:
5496         case R_PPC64_GOT16_HI:
5497         case R_PPC64_GOT16_LO:
5498         case R_PPC64_GOT16_LO_DS:
5499           /* This symbol requires a global offset table entry.  */
5500           sec->has_toc_reloc = 1;
5501           if (r_type == R_PPC64_GOT_TLSLD16
5502               || r_type == R_PPC64_GOT_TLSGD16
5503               || r_type == R_PPC64_GOT_TPREL16_DS
5504               || r_type == R_PPC64_GOT_DTPREL16_DS
5505               || r_type == R_PPC64_GOT16
5506               || r_type == R_PPC64_GOT16_DS)
5507             {
5508               htab->do_multi_toc = 1;
5509               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5510             }
5511
5512           if (ppc64_elf_tdata (abfd)->got == NULL
5513               && !create_got_section (abfd, info))
5514             return FALSE;
5515
5516           if (h != NULL)
5517             {
5518               struct ppc_link_hash_entry *eh;
5519               struct got_entry *ent;
5520
5521               eh = (struct ppc_link_hash_entry *) h;
5522               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5523                 if (ent->addend == rel->r_addend
5524                     && ent->owner == abfd
5525                     && ent->tls_type == tls_type)
5526                   break;
5527               if (ent == NULL)
5528                 {
5529                   bfd_size_type amt = sizeof (*ent);
5530                   ent = bfd_alloc (abfd, amt);
5531                   if (ent == NULL)
5532                     return FALSE;
5533                   ent->next = eh->elf.got.glist;
5534                   ent->addend = rel->r_addend;
5535                   ent->owner = abfd;
5536                   ent->tls_type = tls_type;
5537                   ent->is_indirect = FALSE;
5538                   ent->got.refcount = 0;
5539                   eh->elf.got.glist = ent;
5540                 }
5541               ent->got.refcount += 1;
5542               eh->tls_mask |= tls_type;
5543             }
5544           else
5545             /* This is a global offset table entry for a local symbol.  */
5546             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5547                                         rel->r_addend, tls_type))
5548               return FALSE;
5549
5550           /* We may also need a plt entry if the symbol turns out to be
5551              an ifunc.  */
5552           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5553             {
5554               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5555                 return FALSE;
5556             }
5557           break;
5558
5559         case R_PPC64_PLT16_HA:
5560         case R_PPC64_PLT16_HI:
5561         case R_PPC64_PLT16_LO:
5562         case R_PPC64_PLT32:
5563         case R_PPC64_PLT64:
5564           /* This symbol requires a procedure linkage table entry.  */
5565           plt_list = ifunc;
5566           if (h != NULL)
5567             {
5568               h->needs_plt = 1;
5569               if (h->root.root.string[0] == '.'
5570                   && h->root.root.string[1] != '\0')
5571                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5572               plt_list = &h->plt.plist;
5573             }
5574           if (plt_list == NULL)
5575             {
5576               /* It does not make sense to have a procedure linkage
5577                  table entry for a non-ifunc local symbol.  */
5578               info->callbacks->einfo
5579                 /* xgettext:c-format */
5580                 (_("%H: %s reloc against local symbol\n"),
5581                  abfd, sec, rel->r_offset,
5582                  ppc64_elf_howto_table[r_type]->name);
5583               bfd_set_error (bfd_error_bad_value);
5584               return FALSE;
5585             }
5586           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5587             return FALSE;
5588           break;
5589
5590           /* The following relocations don't need to propagate the
5591              relocation if linking a shared object since they are
5592              section relative.  */
5593         case R_PPC64_SECTOFF:
5594         case R_PPC64_SECTOFF_LO:
5595         case R_PPC64_SECTOFF_HI:
5596         case R_PPC64_SECTOFF_HA:
5597         case R_PPC64_SECTOFF_DS:
5598         case R_PPC64_SECTOFF_LO_DS:
5599         case R_PPC64_DTPREL16:
5600         case R_PPC64_DTPREL16_LO:
5601         case R_PPC64_DTPREL16_HI:
5602         case R_PPC64_DTPREL16_HA:
5603         case R_PPC64_DTPREL16_DS:
5604         case R_PPC64_DTPREL16_LO_DS:
5605         case R_PPC64_DTPREL16_HIGH:
5606         case R_PPC64_DTPREL16_HIGHA:
5607         case R_PPC64_DTPREL16_HIGHER:
5608         case R_PPC64_DTPREL16_HIGHERA:
5609         case R_PPC64_DTPREL16_HIGHEST:
5610         case R_PPC64_DTPREL16_HIGHESTA:
5611           break;
5612
5613           /* Nor do these.  */
5614         case R_PPC64_REL16:
5615         case R_PPC64_REL16_LO:
5616         case R_PPC64_REL16_HI:
5617         case R_PPC64_REL16_HA:
5618         case R_PPC64_REL16DX_HA:
5619           break;
5620
5621           /* Not supported as a dynamic relocation.  */
5622         case R_PPC64_ADDR64_LOCAL:
5623           if (bfd_link_pic (info))
5624             {
5625               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5626                 ppc_howto_init ();
5627               /* xgettext:c-format */
5628               info->callbacks->einfo (_("%H: %s reloc unsupported "
5629                                         "in shared libraries and PIEs.\n"),
5630                                       abfd, sec, rel->r_offset,
5631                                       ppc64_elf_howto_table[r_type]->name);
5632               bfd_set_error (bfd_error_bad_value);
5633               return FALSE;
5634             }
5635           break;
5636
5637         case R_PPC64_TOC16:
5638         case R_PPC64_TOC16_DS:
5639           htab->do_multi_toc = 1;
5640           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5641           /* Fall through.  */
5642         case R_PPC64_TOC16_LO:
5643         case R_PPC64_TOC16_HI:
5644         case R_PPC64_TOC16_HA:
5645         case R_PPC64_TOC16_LO_DS:
5646           sec->has_toc_reloc = 1;
5647           break;
5648
5649           /* Marker reloc.  */
5650         case R_PPC64_ENTRY:
5651           break;
5652
5653           /* This relocation describes the C++ object vtable hierarchy.
5654              Reconstruct it for later use during GC.  */
5655         case R_PPC64_GNU_VTINHERIT:
5656           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5657             return FALSE;
5658           break;
5659
5660           /* This relocation describes which C++ vtable entries are actually
5661              used.  Record for later use during GC.  */
5662         case R_PPC64_GNU_VTENTRY:
5663           BFD_ASSERT (h != NULL);
5664           if (h != NULL
5665               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5666             return FALSE;
5667           break;
5668
5669         case R_PPC64_REL14:
5670         case R_PPC64_REL14_BRTAKEN:
5671         case R_PPC64_REL14_BRNTAKEN:
5672           {
5673             asection *dest = NULL;
5674
5675             /* Heuristic: If jumping outside our section, chances are
5676                we are going to need a stub.  */
5677             if (h != NULL)
5678               {
5679                 /* If the sym is weak it may be overridden later, so
5680                    don't assume we know where a weak sym lives.  */
5681                 if (h->root.type == bfd_link_hash_defined)
5682                   dest = h->root.u.def.section;
5683               }
5684             else
5685               {
5686                 Elf_Internal_Sym *isym;
5687
5688                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5689                                               abfd, r_symndx);
5690                 if (isym == NULL)
5691                   return FALSE;
5692
5693                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5694               }
5695
5696             if (dest != sec)
5697               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5698           }
5699           /* Fall through.  */
5700
5701         case R_PPC64_REL24:
5702           plt_list = ifunc;
5703           if (h != NULL)
5704             {
5705               h->needs_plt = 1;
5706               if (h->root.root.string[0] == '.'
5707                   && h->root.root.string[1] != '\0')
5708                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5709
5710               if (h == tga || h == dottga)
5711                 {
5712                   sec->has_tls_reloc = 1;
5713                   if (rel != relocs
5714                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5715                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5716                     /* We have a new-style __tls_get_addr call with
5717                        a marker reloc.  */
5718                     ;
5719                   else
5720                     /* Mark this section as having an old-style call.  */
5721                     sec->has_tls_get_addr_call = 1;
5722                 }
5723               plt_list = &h->plt.plist;
5724             }
5725
5726           /* We may need a .plt entry if the function this reloc
5727              refers to is in a shared lib.  */
5728           if (plt_list
5729               && !update_plt_info (abfd, plt_list, rel->r_addend))
5730             return FALSE;
5731           break;
5732
5733         case R_PPC64_ADDR14:
5734         case R_PPC64_ADDR14_BRNTAKEN:
5735         case R_PPC64_ADDR14_BRTAKEN:
5736         case R_PPC64_ADDR24:
5737           goto dodyn;
5738
5739         case R_PPC64_TPREL64:
5740           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5741           if (bfd_link_pic (info))
5742             info->flags |= DF_STATIC_TLS;
5743           goto dotlstoc;
5744
5745         case R_PPC64_DTPMOD64:
5746           if (rel + 1 < rel_end
5747               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5748               && rel[1].r_offset == rel->r_offset + 8)
5749             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5750           else
5751             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5752           goto dotlstoc;
5753
5754         case R_PPC64_DTPREL64:
5755           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5756           if (rel != relocs
5757               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5758               && rel[-1].r_offset == rel->r_offset - 8)
5759             /* This is the second reloc of a dtpmod, dtprel pair.
5760                Don't mark with TLS_DTPREL.  */
5761             goto dodyn;
5762
5763         dotlstoc:
5764           sec->has_tls_reloc = 1;
5765           if (h != NULL)
5766             {
5767               struct ppc_link_hash_entry *eh;
5768               eh = (struct ppc_link_hash_entry *) h;
5769               eh->tls_mask |= tls_type;
5770             }
5771           else
5772             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5773                                         rel->r_addend, tls_type))
5774               return FALSE;
5775
5776           ppc64_sec = ppc64_elf_section_data (sec);
5777           if (ppc64_sec->sec_type != sec_toc)
5778             {
5779               bfd_size_type amt;
5780
5781               /* One extra to simplify get_tls_mask.  */
5782               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5783               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5784               if (ppc64_sec->u.toc.symndx == NULL)
5785                 return FALSE;
5786               amt = sec->size * sizeof (bfd_vma) / 8;
5787               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5788               if (ppc64_sec->u.toc.add == NULL)
5789                 return FALSE;
5790               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5791               ppc64_sec->sec_type = sec_toc;
5792             }
5793           BFD_ASSERT (rel->r_offset % 8 == 0);
5794           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5795           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5796
5797           /* Mark the second slot of a GD or LD entry.
5798              -1 to indicate GD and -2 to indicate LD.  */
5799           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5800             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5801           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5802             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5803           goto dodyn;
5804
5805         case R_PPC64_TPREL16:
5806         case R_PPC64_TPREL16_LO:
5807         case R_PPC64_TPREL16_HI:
5808         case R_PPC64_TPREL16_HA:
5809         case R_PPC64_TPREL16_DS:
5810         case R_PPC64_TPREL16_LO_DS:
5811         case R_PPC64_TPREL16_HIGH:
5812         case R_PPC64_TPREL16_HIGHA:
5813         case R_PPC64_TPREL16_HIGHER:
5814         case R_PPC64_TPREL16_HIGHERA:
5815         case R_PPC64_TPREL16_HIGHEST:
5816         case R_PPC64_TPREL16_HIGHESTA:
5817           if (bfd_link_pic (info))
5818             {
5819               info->flags |= DF_STATIC_TLS;
5820               goto dodyn;
5821             }
5822           break;
5823
5824         case R_PPC64_ADDR64:
5825           if (opd_sym_map != NULL
5826               && rel + 1 < rel_end
5827               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5828             {
5829               if (h != NULL)
5830                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5831               else
5832                 {
5833                   asection *s;
5834                   Elf_Internal_Sym *isym;
5835
5836                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5837                                                 abfd, r_symndx);
5838                   if (isym == NULL)
5839                     return FALSE;
5840
5841                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5842                   if (s != NULL && s != sec)
5843                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5844                 }
5845             }
5846           /* Fall through.  */
5847
5848         case R_PPC64_ADDR16:
5849         case R_PPC64_ADDR16_DS:
5850         case R_PPC64_ADDR16_HA:
5851         case R_PPC64_ADDR16_HI:
5852         case R_PPC64_ADDR16_HIGH:
5853         case R_PPC64_ADDR16_HIGHA:
5854         case R_PPC64_ADDR16_HIGHER:
5855         case R_PPC64_ADDR16_HIGHERA:
5856         case R_PPC64_ADDR16_HIGHEST:
5857         case R_PPC64_ADDR16_HIGHESTA:
5858         case R_PPC64_ADDR16_LO:
5859         case R_PPC64_ADDR16_LO_DS:
5860           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5861               && rel->r_addend == 0)
5862             {
5863               /* We may need a .plt entry if this reloc refers to a
5864                  function in a shared lib.  */
5865               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5866                 return FALSE;
5867               h->pointer_equality_needed = 1;
5868             }
5869           /* Fall through.  */
5870
5871         case R_PPC64_REL30:
5872         case R_PPC64_REL32:
5873         case R_PPC64_REL64:
5874         case R_PPC64_ADDR32:
5875         case R_PPC64_UADDR16:
5876         case R_PPC64_UADDR32:
5877         case R_PPC64_UADDR64:
5878         case R_PPC64_TOC:
5879           if (h != NULL && !bfd_link_pic (info))
5880             /* We may need a copy reloc.  */
5881             h->non_got_ref = 1;
5882
5883           /* Don't propagate .opd relocs.  */
5884           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5885             break;
5886
5887           /* If we are creating a shared library, and this is a reloc
5888              against a global symbol, or a non PC relative reloc
5889              against a local symbol, then we need to copy the reloc
5890              into the shared library.  However, if we are linking with
5891              -Bsymbolic, we do not need to copy a reloc against a
5892              global symbol which is defined in an object we are
5893              including in the link (i.e., DEF_REGULAR is set).  At
5894              this point we have not seen all the input files, so it is
5895              possible that DEF_REGULAR is not set now but will be set
5896              later (it is never cleared).  In case of a weak definition,
5897              DEF_REGULAR may be cleared later by a strong definition in
5898              a shared library.  We account for that possibility below by
5899              storing information in the dyn_relocs field of the hash
5900              table entry.  A similar situation occurs when creating
5901              shared libraries and symbol visibility changes render the
5902              symbol local.
5903
5904              If on the other hand, we are creating an executable, we
5905              may need to keep relocations for symbols satisfied by a
5906              dynamic library if we manage to avoid copy relocs for the
5907              symbol.  */
5908         dodyn:
5909           if ((bfd_link_pic (info)
5910                && (must_be_dyn_reloc (info, r_type)
5911                    || (h != NULL
5912                        && (!SYMBOLIC_BIND (info, h)
5913                            || h->root.type == bfd_link_hash_defweak
5914                            || !h->def_regular))))
5915               || (ELIMINATE_COPY_RELOCS
5916                   && !bfd_link_pic (info)
5917                   && h != NULL
5918                   && (h->root.type == bfd_link_hash_defweak
5919                       || !h->def_regular))
5920               || (!bfd_link_pic (info)
5921                   && ifunc != NULL))
5922             {
5923               /* We must copy these reloc types into the output file.
5924                  Create a reloc section in dynobj and make room for
5925                  this reloc.  */
5926               if (sreloc == NULL)
5927                 {
5928                   sreloc = _bfd_elf_make_dynamic_reloc_section
5929                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5930
5931                   if (sreloc == NULL)
5932                     return FALSE;
5933                 }
5934
5935               /* If this is a global symbol, we count the number of
5936                  relocations we need for this symbol.  */
5937               if (h != NULL)
5938                 {
5939                   struct elf_dyn_relocs *p;
5940                   struct elf_dyn_relocs **head;
5941
5942                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5943                   p = *head;
5944                   if (p == NULL || p->sec != sec)
5945                     {
5946                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5947                       if (p == NULL)
5948                         return FALSE;
5949                       p->next = *head;
5950                       *head = p;
5951                       p->sec = sec;
5952                       p->count = 0;
5953                       p->pc_count = 0;
5954                     }
5955                   p->count += 1;
5956                   if (!must_be_dyn_reloc (info, r_type))
5957                     p->pc_count += 1;
5958                 }
5959               else
5960                 {
5961                   /* Track dynamic relocs needed for local syms too.
5962                      We really need local syms available to do this
5963                      easily.  Oh well.  */
5964                   struct ppc_dyn_relocs *p;
5965                   struct ppc_dyn_relocs **head;
5966                   bfd_boolean is_ifunc;
5967                   asection *s;
5968                   void *vpp;
5969                   Elf_Internal_Sym *isym;
5970
5971                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5972                                                 abfd, r_symndx);
5973                   if (isym == NULL)
5974                     return FALSE;
5975
5976                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5977                   if (s == NULL)
5978                     s = sec;
5979
5980                   vpp = &elf_section_data (s)->local_dynrel;
5981                   head = (struct ppc_dyn_relocs **) vpp;
5982                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5983                   p = *head;
5984                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5985                     p = p->next;
5986                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5987                     {
5988                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5989                       if (p == NULL)
5990                         return FALSE;
5991                       p->next = *head;
5992                       *head = p;
5993                       p->sec = sec;
5994                       p->ifunc = is_ifunc;
5995                       p->count = 0;
5996                     }
5997                   p->count += 1;
5998                 }
5999             }
6000           break;
6001
6002         default:
6003           break;
6004         }
6005     }
6006
6007   return TRUE;
6008 }
6009
6010 /* Merge backend specific data from an object file to the output
6011    object file when linking.  */
6012
6013 static bfd_boolean
6014 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6015 {
6016   bfd *obfd = info->output_bfd;
6017   unsigned long iflags, oflags;
6018
6019   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6020     return TRUE;
6021
6022   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6023     return TRUE;
6024
6025   if (!_bfd_generic_verify_endian_match (ibfd, info))
6026     return FALSE;
6027
6028   iflags = elf_elfheader (ibfd)->e_flags;
6029   oflags = elf_elfheader (obfd)->e_flags;
6030
6031   if (iflags & ~EF_PPC64_ABI)
6032     {
6033       _bfd_error_handler
6034         /* xgettext:c-format */
6035         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6036       bfd_set_error (bfd_error_bad_value);
6037       return FALSE;
6038     }
6039   else if (iflags != oflags && iflags != 0)
6040     {
6041       _bfd_error_handler
6042         /* xgettext:c-format */
6043         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6044          ibfd, iflags, oflags);
6045       bfd_set_error (bfd_error_bad_value);
6046       return FALSE;
6047     }
6048
6049   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6050
6051   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6052   _bfd_elf_merge_object_attributes (ibfd, info);
6053
6054   return TRUE;
6055 }
6056
6057 static bfd_boolean
6058 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6059 {
6060   /* Print normal ELF private data.  */
6061   _bfd_elf_print_private_bfd_data (abfd, ptr);
6062
6063   if (elf_elfheader (abfd)->e_flags != 0)
6064     {
6065       FILE *file = ptr;
6066
6067       fprintf (file, _("private flags = 0x%lx:"),
6068                elf_elfheader (abfd)->e_flags);
6069
6070       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6071         fprintf (file, _(" [abiv%ld]"),
6072                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6073       fputc ('\n', file);
6074     }
6075
6076   return TRUE;
6077 }
6078
6079 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6080    of the code entry point, and its section, which must be in the same
6081    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6082
6083 static bfd_vma
6084 opd_entry_value (asection *opd_sec,
6085                  bfd_vma offset,
6086                  asection **code_sec,
6087                  bfd_vma *code_off,
6088                  bfd_boolean in_code_sec)
6089 {
6090   bfd *opd_bfd = opd_sec->owner;
6091   Elf_Internal_Rela *relocs;
6092   Elf_Internal_Rela *lo, *hi, *look;
6093   bfd_vma val;
6094
6095   /* No relocs implies we are linking a --just-symbols object, or looking
6096      at a final linked executable with addr2line or somesuch.  */
6097   if (opd_sec->reloc_count == 0)
6098     {
6099       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6100
6101       if (contents == NULL)
6102         {
6103           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6104             return (bfd_vma) -1;
6105           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6106         }
6107
6108       /* PR 17512: file: 64b9dfbb.  */
6109       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6110         return (bfd_vma) -1;
6111
6112       val = bfd_get_64 (opd_bfd, contents + offset);
6113       if (code_sec != NULL)
6114         {
6115           asection *sec, *likely = NULL;
6116
6117           if (in_code_sec)
6118             {
6119               sec = *code_sec;
6120               if (sec->vma <= val
6121                   && val < sec->vma + sec->size)
6122                 likely = sec;
6123               else
6124                 val = -1;
6125             }
6126           else
6127             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6128               if (sec->vma <= val
6129                   && (sec->flags & SEC_LOAD) != 0
6130                   && (sec->flags & SEC_ALLOC) != 0)
6131                 likely = sec;
6132           if (likely != NULL)
6133             {
6134               *code_sec = likely;
6135               if (code_off != NULL)
6136                 *code_off = val - likely->vma;
6137             }
6138         }
6139       return val;
6140     }
6141
6142   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6143
6144   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6145   if (relocs == NULL)
6146     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6147   /* PR 17512: file: df8e1fd6.  */
6148   if (relocs == NULL)
6149     return (bfd_vma) -1;
6150
6151   /* Go find the opd reloc at the sym address.  */
6152   lo = relocs;
6153   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6154   val = (bfd_vma) -1;
6155   while (lo < hi)
6156     {
6157       look = lo + (hi - lo) / 2;
6158       if (look->r_offset < offset)
6159         lo = look + 1;
6160       else if (look->r_offset > offset)
6161         hi = look;
6162       else
6163         {
6164           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6165
6166           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6167               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6168             {
6169               unsigned long symndx = ELF64_R_SYM (look->r_info);
6170               asection *sec = NULL;
6171
6172               if (symndx >= symtab_hdr->sh_info
6173                   && elf_sym_hashes (opd_bfd) != NULL)
6174                 {
6175                   struct elf_link_hash_entry **sym_hashes;
6176                   struct elf_link_hash_entry *rh;
6177
6178                   sym_hashes = elf_sym_hashes (opd_bfd);
6179                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6180                   if (rh != NULL)
6181                     {
6182                       rh = elf_follow_link (rh);
6183                       if (rh->root.type != bfd_link_hash_defined
6184                           && rh->root.type != bfd_link_hash_defweak)
6185                         break;
6186                       if (rh->root.u.def.section->owner == opd_bfd)
6187                         {
6188                           val = rh->root.u.def.value;
6189                           sec = rh->root.u.def.section;
6190                         }
6191                     }
6192                 }
6193
6194               if (sec == NULL)
6195                 {
6196                   Elf_Internal_Sym *sym;
6197
6198                   if (symndx < symtab_hdr->sh_info)
6199                     {
6200                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6201                       if (sym == NULL)
6202                         {
6203                           size_t symcnt = symtab_hdr->sh_info;
6204                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6205                                                       symcnt, 0,
6206                                                       NULL, NULL, NULL);
6207                           if (sym == NULL)
6208                             break;
6209                           symtab_hdr->contents = (bfd_byte *) sym;
6210                         }
6211                       sym += symndx;
6212                     }
6213                   else
6214                     {
6215                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6216                                                   1, symndx,
6217                                                   NULL, NULL, NULL);
6218                       if (sym == NULL)
6219                         break;
6220                     }
6221                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6222                   if (sec == NULL)
6223                     break;
6224                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6225                   val = sym->st_value;
6226                 }
6227
6228               val += look->r_addend;
6229               if (code_off != NULL)
6230                 *code_off = val;
6231               if (code_sec != NULL)
6232                 {
6233                   if (in_code_sec && *code_sec != sec)
6234                     return -1;
6235                   else
6236                     *code_sec = sec;
6237                 }
6238               if (sec->output_section != NULL)
6239                 val += sec->output_section->vma + sec->output_offset;
6240             }
6241           break;
6242         }
6243     }
6244
6245   return val;
6246 }
6247
6248 /* If the ELF symbol SYM might be a function in SEC, return the
6249    function size and set *CODE_OFF to the function's entry point,
6250    otherwise return zero.  */
6251
6252 static bfd_size_type
6253 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6254                               bfd_vma *code_off)
6255 {
6256   bfd_size_type size;
6257
6258   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6259                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6260     return 0;
6261
6262   size = 0;
6263   if (!(sym->flags & BSF_SYNTHETIC))
6264     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6265
6266   if (strcmp (sym->section->name, ".opd") == 0)
6267     {
6268       struct _opd_sec_data *opd = get_opd_info (sym->section);
6269       bfd_vma symval = sym->value;
6270
6271       if (opd != NULL
6272           && opd->adjust != NULL
6273           && elf_section_data (sym->section)->relocs != NULL)
6274         {
6275           /* opd_entry_value will use cached relocs that have been
6276              adjusted, but with raw symbols.  That means both local
6277              and global symbols need adjusting.  */
6278           long adjust = opd->adjust[OPD_NDX (symval)];
6279           if (adjust == -1)
6280             return 0;
6281           symval += adjust;
6282         }
6283
6284       if (opd_entry_value (sym->section, symval,
6285                            &sec, code_off, TRUE) == (bfd_vma) -1)
6286         return 0;
6287       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6288          symbol.  This size has nothing to do with the code size of the
6289          function, which is what we're supposed to return, but the
6290          code size isn't available without looking up the dot-sym.
6291          However, doing that would be a waste of time particularly
6292          since elf_find_function will look at the dot-sym anyway.
6293          Now, elf_find_function will keep the largest size of any
6294          function sym found at the code address of interest, so return
6295          1 here to avoid it incorrectly caching a larger function size
6296          for a small function.  This does mean we return the wrong
6297          size for a new-ABI function of size 24, but all that does is
6298          disable caching for such functions.  */
6299       if (size == 24)
6300         size = 1;
6301     }
6302   else
6303     {
6304       if (sym->section != sec)
6305         return 0;
6306       *code_off = sym->value;
6307     }
6308   if (size == 0)
6309     size = 1;
6310   return size;
6311 }
6312
6313 /* Return true if symbol is defined in a regular object file.  */
6314
6315 static bfd_boolean
6316 is_static_defined (struct elf_link_hash_entry *h)
6317 {
6318   return ((h->root.type == bfd_link_hash_defined
6319            || h->root.type == bfd_link_hash_defweak)
6320           && h->root.u.def.section != NULL
6321           && h->root.u.def.section->output_section != NULL);
6322 }
6323
6324 /* If FDH is a function descriptor symbol, return the associated code
6325    entry symbol if it is defined.  Return NULL otherwise.  */
6326
6327 static struct ppc_link_hash_entry *
6328 defined_code_entry (struct ppc_link_hash_entry *fdh)
6329 {
6330   if (fdh->is_func_descriptor)
6331     {
6332       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6333       if (fh->elf.root.type == bfd_link_hash_defined
6334           || fh->elf.root.type == bfd_link_hash_defweak)
6335         return fh;
6336     }
6337   return NULL;
6338 }
6339
6340 /* If FH is a function code entry symbol, return the associated
6341    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6342
6343 static struct ppc_link_hash_entry *
6344 defined_func_desc (struct ppc_link_hash_entry *fh)
6345 {
6346   if (fh->oh != NULL
6347       && fh->oh->is_func_descriptor)
6348     {
6349       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6350       if (fdh->elf.root.type == bfd_link_hash_defined
6351           || fdh->elf.root.type == bfd_link_hash_defweak)
6352         return fdh;
6353     }
6354   return NULL;
6355 }
6356
6357 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6358
6359 /* Garbage collect sections, after first dealing with dot-symbols.  */
6360
6361 static bfd_boolean
6362 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6363 {
6364   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6365
6366   if (htab != NULL && htab->need_func_desc_adj)
6367     {
6368       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6369       htab->need_func_desc_adj = 0;
6370     }
6371   return bfd_elf_gc_sections (abfd, info);
6372 }
6373
6374 /* Mark all our entry sym sections, both opd and code section.  */
6375
6376 static void
6377 ppc64_elf_gc_keep (struct bfd_link_info *info)
6378 {
6379   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6380   struct bfd_sym_chain *sym;
6381
6382   if (htab == NULL)
6383     return;
6384
6385   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6386     {
6387       struct ppc_link_hash_entry *eh, *fh;
6388       asection *sec;
6389
6390       eh = (struct ppc_link_hash_entry *)
6391         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6392       if (eh == NULL)
6393         continue;
6394       if (eh->elf.root.type != bfd_link_hash_defined
6395           && eh->elf.root.type != bfd_link_hash_defweak)
6396         continue;
6397
6398       fh = defined_code_entry (eh);
6399       if (fh != NULL)
6400         {
6401           sec = fh->elf.root.u.def.section;
6402           sec->flags |= SEC_KEEP;
6403         }
6404       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6405                && opd_entry_value (eh->elf.root.u.def.section,
6406                                    eh->elf.root.u.def.value,
6407                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6408         sec->flags |= SEC_KEEP;
6409
6410       sec = eh->elf.root.u.def.section;
6411       sec->flags |= SEC_KEEP;
6412     }
6413 }
6414
6415 /* Mark sections containing dynamically referenced symbols.  When
6416    building shared libraries, we must assume that any visible symbol is
6417    referenced.  */
6418
6419 static bfd_boolean
6420 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6421 {
6422   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6423   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6424   struct ppc_link_hash_entry *fdh;
6425   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6426
6427   /* Dynamic linking info is on the func descriptor sym.  */
6428   fdh = defined_func_desc (eh);
6429   if (fdh != NULL)
6430     eh = fdh;
6431
6432   if ((eh->elf.root.type == bfd_link_hash_defined
6433        || eh->elf.root.type == bfd_link_hash_defweak)
6434       && (eh->elf.ref_dynamic
6435           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6436               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6437               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6438               && (!bfd_link_executable (info)
6439                   || info->gc_keep_exported
6440                   || info->export_dynamic
6441                   || (eh->elf.dynamic
6442                       && d != NULL
6443                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6444               && (eh->elf.versioned >= versioned
6445                   || !bfd_hide_sym_by_version (info->version_info,
6446                                                eh->elf.root.root.string)))))
6447     {
6448       asection *code_sec;
6449       struct ppc_link_hash_entry *fh;
6450
6451       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6452
6453       /* Function descriptor syms cause the associated
6454          function code sym section to be marked.  */
6455       fh = defined_code_entry (eh);
6456       if (fh != NULL)
6457         {
6458           code_sec = fh->elf.root.u.def.section;
6459           code_sec->flags |= SEC_KEEP;
6460         }
6461       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6462                && opd_entry_value (eh->elf.root.u.def.section,
6463                                    eh->elf.root.u.def.value,
6464                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6465         code_sec->flags |= SEC_KEEP;
6466     }
6467
6468   return TRUE;
6469 }
6470
6471 /* Return the section that should be marked against GC for a given
6472    relocation.  */
6473
6474 static asection *
6475 ppc64_elf_gc_mark_hook (asection *sec,
6476                         struct bfd_link_info *info,
6477                         Elf_Internal_Rela *rel,
6478                         struct elf_link_hash_entry *h,
6479                         Elf_Internal_Sym *sym)
6480 {
6481   asection *rsec;
6482
6483   /* Syms return NULL if we're marking .opd, so we avoid marking all
6484      function sections, as all functions are referenced in .opd.  */
6485   rsec = NULL;
6486   if (get_opd_info (sec) != NULL)
6487     return rsec;
6488
6489   if (h != NULL)
6490     {
6491       enum elf_ppc64_reloc_type r_type;
6492       struct ppc_link_hash_entry *eh, *fh, *fdh;
6493
6494       r_type = ELF64_R_TYPE (rel->r_info);
6495       switch (r_type)
6496         {
6497         case R_PPC64_GNU_VTINHERIT:
6498         case R_PPC64_GNU_VTENTRY:
6499           break;
6500
6501         default:
6502           switch (h->root.type)
6503             {
6504             case bfd_link_hash_defined:
6505             case bfd_link_hash_defweak:
6506               eh = (struct ppc_link_hash_entry *) h;
6507               fdh = defined_func_desc (eh);
6508               if (fdh != NULL)
6509                 {
6510                   /* -mcall-aixdesc code references the dot-symbol on
6511                      a call reloc.  Mark the function descriptor too
6512                      against garbage collection.  */
6513                   fdh->elf.mark = 1;
6514                   if (fdh->elf.u.weakdef != NULL)
6515                     fdh->elf.u.weakdef->mark = 1;
6516                   eh = fdh;
6517                 }
6518
6519               /* Function descriptor syms cause the associated
6520                  function code sym section to be marked.  */
6521               fh = defined_code_entry (eh);
6522               if (fh != NULL)
6523                 {
6524                   /* They also mark their opd section.  */
6525                   eh->elf.root.u.def.section->gc_mark = 1;
6526
6527                   rsec = fh->elf.root.u.def.section;
6528                 }
6529               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6530                        && opd_entry_value (eh->elf.root.u.def.section,
6531                                            eh->elf.root.u.def.value,
6532                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6533                 eh->elf.root.u.def.section->gc_mark = 1;
6534               else
6535                 rsec = h->root.u.def.section;
6536               break;
6537
6538             case bfd_link_hash_common:
6539               rsec = h->root.u.c.p->section;
6540               break;
6541
6542             default:
6543               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6544             }
6545         }
6546     }
6547   else
6548     {
6549       struct _opd_sec_data *opd;
6550
6551       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6552       opd = get_opd_info (rsec);
6553       if (opd != NULL && opd->func_sec != NULL)
6554         {
6555           rsec->gc_mark = 1;
6556
6557           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6558         }
6559     }
6560
6561   return rsec;
6562 }
6563
6564 /* Update the .got, .plt. and dynamic reloc reference counts for the
6565    section being removed.  */
6566
6567 static bfd_boolean
6568 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6569                          asection *sec, const Elf_Internal_Rela *relocs)
6570 {
6571   struct ppc_link_hash_table *htab;
6572   Elf_Internal_Shdr *symtab_hdr;
6573   struct elf_link_hash_entry **sym_hashes;
6574   struct got_entry **local_got_ents;
6575   const Elf_Internal_Rela *rel, *relend;
6576
6577   if (bfd_link_relocatable (info))
6578     return TRUE;
6579
6580   if ((sec->flags & SEC_ALLOC) == 0)
6581     return TRUE;
6582
6583   elf_section_data (sec)->local_dynrel = NULL;
6584
6585   htab = ppc_hash_table (info);
6586   if (htab == NULL)
6587     return FALSE;
6588
6589   symtab_hdr = &elf_symtab_hdr (abfd);
6590   sym_hashes = elf_sym_hashes (abfd);
6591   local_got_ents = elf_local_got_ents (abfd);
6592
6593   relend = relocs + sec->reloc_count;
6594   for (rel = relocs; rel < relend; rel++)
6595     {
6596       unsigned long r_symndx;
6597       enum elf_ppc64_reloc_type r_type;
6598       struct elf_link_hash_entry *h = NULL;
6599       struct plt_entry **plt_list = NULL;
6600       unsigned char tls_type = 0;
6601
6602       r_symndx = ELF64_R_SYM (rel->r_info);
6603       r_type = ELF64_R_TYPE (rel->r_info);
6604       if (r_symndx >= symtab_hdr->sh_info)
6605         {
6606           struct ppc_link_hash_entry *eh;
6607           struct elf_dyn_relocs **pp;
6608           struct elf_dyn_relocs *p;
6609
6610           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6611           h = elf_follow_link (h);
6612           eh = (struct ppc_link_hash_entry *) h;
6613
6614           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6615             if (p->sec == sec)
6616               {
6617                 /* Everything must go for SEC.  */
6618                 *pp = p->next;
6619                 break;
6620               }
6621         }
6622
6623       switch (r_type)
6624         {
6625         case R_PPC64_GOT_TLSLD16:
6626         case R_PPC64_GOT_TLSLD16_LO:
6627         case R_PPC64_GOT_TLSLD16_HI:
6628         case R_PPC64_GOT_TLSLD16_HA:
6629           tls_type = TLS_TLS | TLS_LD;
6630           goto dogot;
6631
6632         case R_PPC64_GOT_TLSGD16:
6633         case R_PPC64_GOT_TLSGD16_LO:
6634         case R_PPC64_GOT_TLSGD16_HI:
6635         case R_PPC64_GOT_TLSGD16_HA:
6636           tls_type = TLS_TLS | TLS_GD;
6637           goto dogot;
6638
6639         case R_PPC64_GOT_TPREL16_DS:
6640         case R_PPC64_GOT_TPREL16_LO_DS:
6641         case R_PPC64_GOT_TPREL16_HI:
6642         case R_PPC64_GOT_TPREL16_HA:
6643           tls_type = TLS_TLS | TLS_TPREL;
6644           goto dogot;
6645
6646         case R_PPC64_GOT_DTPREL16_DS:
6647         case R_PPC64_GOT_DTPREL16_LO_DS:
6648         case R_PPC64_GOT_DTPREL16_HI:
6649         case R_PPC64_GOT_DTPREL16_HA:
6650           tls_type = TLS_TLS | TLS_DTPREL;
6651           goto dogot;
6652
6653         case R_PPC64_GOT16:
6654         case R_PPC64_GOT16_DS:
6655         case R_PPC64_GOT16_HA:
6656         case R_PPC64_GOT16_HI:
6657         case R_PPC64_GOT16_LO:
6658         case R_PPC64_GOT16_LO_DS:
6659         dogot:
6660           {
6661             struct got_entry *ent;
6662
6663             if (h != NULL)
6664               ent = h->got.glist;
6665             else
6666               ent = local_got_ents[r_symndx];
6667
6668             for (; ent != NULL; ent = ent->next)
6669               if (ent->addend == rel->r_addend
6670                   && ent->owner == abfd
6671                   && ent->tls_type == tls_type)
6672                 break;
6673             if (ent == NULL)
6674               abort ();
6675             if (ent->got.refcount > 0)
6676               ent->got.refcount -= 1;
6677           }
6678           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6679             plt_list = &h->plt.plist;
6680           break;
6681
6682         case R_PPC64_PLT16_HA:
6683         case R_PPC64_PLT16_HI:
6684         case R_PPC64_PLT16_LO:
6685         case R_PPC64_PLT32:
6686         case R_PPC64_PLT64:
6687         case R_PPC64_REL14:
6688         case R_PPC64_REL14_BRNTAKEN:
6689         case R_PPC64_REL14_BRTAKEN:
6690         case R_PPC64_REL24:
6691           if (h != NULL)
6692             plt_list = &h->plt.plist;
6693           else if (local_got_ents != NULL)
6694             {
6695               struct plt_entry **local_plt = (struct plt_entry **)
6696                 (local_got_ents + symtab_hdr->sh_info);
6697               unsigned char *local_got_tls_masks = (unsigned char *)
6698                 (local_plt + symtab_hdr->sh_info);
6699               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6700                 plt_list = local_plt + r_symndx;
6701             }
6702           break;
6703
6704         case R_PPC64_ADDR64:
6705         case R_PPC64_ADDR16:
6706         case R_PPC64_ADDR16_DS:
6707         case R_PPC64_ADDR16_HA:
6708         case R_PPC64_ADDR16_HI:
6709         case R_PPC64_ADDR16_HIGH:
6710         case R_PPC64_ADDR16_HIGHA:
6711         case R_PPC64_ADDR16_HIGHER:
6712         case R_PPC64_ADDR16_HIGHERA:
6713         case R_PPC64_ADDR16_HIGHEST:
6714         case R_PPC64_ADDR16_HIGHESTA:
6715         case R_PPC64_ADDR16_LO:
6716         case R_PPC64_ADDR16_LO_DS:
6717           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6718               && rel->r_addend == 0)
6719             plt_list = &h->plt.plist;
6720           break;
6721
6722         default:
6723           break;
6724         }
6725       if (plt_list != NULL)
6726         {
6727           struct plt_entry *ent;
6728
6729           for (ent = *plt_list; ent != NULL; ent = ent->next)
6730             if (ent->addend == rel->r_addend)
6731               break;
6732           if (ent != NULL && ent->plt.refcount > 0)
6733             ent->plt.refcount -= 1;
6734         }
6735     }
6736   return TRUE;
6737 }
6738
6739 /* The maximum size of .sfpr.  */
6740 #define SFPR_MAX (218*4)
6741
6742 struct sfpr_def_parms
6743 {
6744   const char name[12];
6745   unsigned char lo, hi;
6746   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6747   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6748 };
6749
6750 /* Auto-generate _save*, _rest* functions in .sfpr.
6751    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6752    instead.  */
6753
6754 static bfd_boolean
6755 sfpr_define (struct bfd_link_info *info,
6756              const struct sfpr_def_parms *parm,
6757              asection *stub_sec)
6758 {
6759   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6760   unsigned int i;
6761   size_t len = strlen (parm->name);
6762   bfd_boolean writing = FALSE;
6763   char sym[16];
6764
6765   if (htab == NULL)
6766     return FALSE;
6767
6768   memcpy (sym, parm->name, len);
6769   sym[len + 2] = 0;
6770
6771   for (i = parm->lo; i <= parm->hi; i++)
6772     {
6773       struct ppc_link_hash_entry *h;
6774
6775       sym[len + 0] = i / 10 + '0';
6776       sym[len + 1] = i % 10 + '0';
6777       h = (struct ppc_link_hash_entry *)
6778         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6779       if (stub_sec != NULL)
6780         {
6781           if (h != NULL
6782               && h->elf.root.type == bfd_link_hash_defined
6783               && h->elf.root.u.def.section == htab->sfpr)
6784             {
6785               struct elf_link_hash_entry *s;
6786               char buf[32];
6787               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6788               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6789               if (s == NULL)
6790                 return FALSE;
6791               if (s->root.type == bfd_link_hash_new
6792                   || (s->root.type = bfd_link_hash_defined
6793                       && s->root.u.def.section == stub_sec))
6794                 {
6795                   s->root.type = bfd_link_hash_defined;
6796                   s->root.u.def.section = stub_sec;
6797                   s->root.u.def.value = (stub_sec->size
6798                                          + h->elf.root.u.def.value);
6799                   s->ref_regular = 1;
6800                   s->def_regular = 1;
6801                   s->ref_regular_nonweak = 1;
6802                   s->forced_local = 1;
6803                   s->non_elf = 0;
6804                   s->root.linker_def = 1;
6805                 }
6806             }
6807           continue;
6808         }
6809       if (h != NULL)
6810         {
6811           h->save_res = 1;
6812           if (!h->elf.def_regular)
6813             {
6814               h->elf.root.type = bfd_link_hash_defined;
6815               h->elf.root.u.def.section = htab->sfpr;
6816               h->elf.root.u.def.value = htab->sfpr->size;
6817               h->elf.type = STT_FUNC;
6818               h->elf.def_regular = 1;
6819               h->elf.non_elf = 0;
6820               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6821               writing = TRUE;
6822               if (htab->sfpr->contents == NULL)
6823                 {
6824                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6825                   if (htab->sfpr->contents == NULL)
6826                     return FALSE;
6827                 }
6828             }
6829         }
6830       if (writing)
6831         {
6832           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6833           if (i != parm->hi)
6834             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6835           else
6836             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6837           htab->sfpr->size = p - htab->sfpr->contents;
6838         }
6839     }
6840
6841   return TRUE;
6842 }
6843
6844 static bfd_byte *
6845 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6846 {
6847   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6848   return p + 4;
6849 }
6850
6851 static bfd_byte *
6852 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6853 {
6854   p = savegpr0 (abfd, p, r);
6855   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6856   p = p + 4;
6857   bfd_put_32 (abfd, BLR, p);
6858   return p + 4;
6859 }
6860
6861 static bfd_byte *
6862 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6863 {
6864   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6865   return p + 4;
6866 }
6867
6868 static bfd_byte *
6869 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6870 {
6871   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6872   p = p + 4;
6873   p = restgpr0 (abfd, p, r);
6874   bfd_put_32 (abfd, MTLR_R0, p);
6875   p = p + 4;
6876   if (r == 29)
6877     {
6878       p = restgpr0 (abfd, p, 30);
6879       p = restgpr0 (abfd, p, 31);
6880     }
6881   bfd_put_32 (abfd, BLR, p);
6882   return p + 4;
6883 }
6884
6885 static bfd_byte *
6886 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6887 {
6888   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6889   return p + 4;
6890 }
6891
6892 static bfd_byte *
6893 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6894 {
6895   p = savegpr1 (abfd, p, r);
6896   bfd_put_32 (abfd, BLR, p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6904   return p + 4;
6905 }
6906
6907 static bfd_byte *
6908 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6909 {
6910   p = restgpr1 (abfd, p, r);
6911   bfd_put_32 (abfd, BLR, p);
6912   return p + 4;
6913 }
6914
6915 static bfd_byte *
6916 savefpr (bfd *abfd, bfd_byte *p, int r)
6917 {
6918   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6919   return p + 4;
6920 }
6921
6922 static bfd_byte *
6923 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6924 {
6925   p = savefpr (abfd, p, r);
6926   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6927   p = p + 4;
6928   bfd_put_32 (abfd, BLR, p);
6929   return p + 4;
6930 }
6931
6932 static bfd_byte *
6933 restfpr (bfd *abfd, bfd_byte *p, int r)
6934 {
6935   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6936   return p + 4;
6937 }
6938
6939 static bfd_byte *
6940 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6941 {
6942   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6943   p = p + 4;
6944   p = restfpr (abfd, p, r);
6945   bfd_put_32 (abfd, MTLR_R0, p);
6946   p = p + 4;
6947   if (r == 29)
6948     {
6949       p = restfpr (abfd, p, 30);
6950       p = restfpr (abfd, p, 31);
6951     }
6952   bfd_put_32 (abfd, BLR, p);
6953   return p + 4;
6954 }
6955
6956 static bfd_byte *
6957 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6958 {
6959   p = savefpr (abfd, p, r);
6960   bfd_put_32 (abfd, BLR, p);
6961   return p + 4;
6962 }
6963
6964 static bfd_byte *
6965 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6966 {
6967   p = restfpr (abfd, p, r);
6968   bfd_put_32 (abfd, BLR, p);
6969   return p + 4;
6970 }
6971
6972 static bfd_byte *
6973 savevr (bfd *abfd, bfd_byte *p, int r)
6974 {
6975   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6976   p = p + 4;
6977   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6978   return p + 4;
6979 }
6980
6981 static bfd_byte *
6982 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6983 {
6984   p = savevr (abfd, p, r);
6985   bfd_put_32 (abfd, BLR, p);
6986   return p + 4;
6987 }
6988
6989 static bfd_byte *
6990 restvr (bfd *abfd, bfd_byte *p, int r)
6991 {
6992   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6993   p = p + 4;
6994   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6995   return p + 4;
6996 }
6997
6998 static bfd_byte *
6999 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7000 {
7001   p = restvr (abfd, p, r);
7002   bfd_put_32 (abfd, BLR, p);
7003   return p + 4;
7004 }
7005
7006 /* Called via elf_link_hash_traverse to transfer dynamic linking
7007    information on function code symbol entries to their corresponding
7008    function descriptor symbol entries.  */
7009
7010 static bfd_boolean
7011 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7012 {
7013   struct bfd_link_info *info;
7014   struct ppc_link_hash_table *htab;
7015   struct ppc_link_hash_entry *fh;
7016   struct ppc_link_hash_entry *fdh;
7017   bfd_boolean force_local;
7018
7019   fh = (struct ppc_link_hash_entry *) h;
7020   if (fh->elf.root.type == bfd_link_hash_indirect)
7021     return TRUE;
7022
7023   if (!fh->is_func)
7024     return TRUE;
7025
7026   if (fh->elf.root.root.string[0] != '.'
7027       || fh->elf.root.root.string[1] == '\0')
7028     return TRUE;
7029
7030   info = inf;
7031   htab = ppc_hash_table (info);
7032   if (htab == NULL)
7033     return FALSE;
7034
7035   /* Find the corresponding function descriptor symbol.  */
7036   fdh = lookup_fdh (fh, htab);
7037
7038   /* Resolve undefined references to dot-symbols as the value
7039      in the function descriptor, if we have one in a regular object.
7040      This is to satisfy cases like ".quad .foo".  Calls to functions
7041      in dynamic objects are handled elsewhere.  */
7042   if ((fh->elf.root.type == bfd_link_hash_undefined
7043        || fh->elf.root.type == bfd_link_hash_undefweak)
7044       && (fdh->elf.root.type == bfd_link_hash_defined
7045           || fdh->elf.root.type == bfd_link_hash_defweak)
7046       && get_opd_info (fdh->elf.root.u.def.section) != NULL
7047       && opd_entry_value (fdh->elf.root.u.def.section,
7048                           fdh->elf.root.u.def.value,
7049                           &fh->elf.root.u.def.section,
7050                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7051     {
7052       fh->elf.root.type = fdh->elf.root.type;
7053       fh->elf.forced_local = 1;
7054       fh->elf.def_regular = fdh->elf.def_regular;
7055       fh->elf.def_dynamic = fdh->elf.def_dynamic;
7056     }
7057
7058   if (!fh->elf.dynamic)
7059     {
7060       struct plt_entry *ent;
7061
7062       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7063         if (ent->plt.refcount > 0)
7064           break;
7065       if (ent == NULL)
7066         return TRUE;
7067     }
7068
7069   /* Create a descriptor as undefined if necessary.  */
7070   if (fdh == NULL
7071       && !bfd_link_executable (info)
7072       && (fh->elf.root.type == bfd_link_hash_undefined
7073           || fh->elf.root.type == bfd_link_hash_undefweak))
7074     {
7075       fdh = make_fdh (info, fh);
7076       if (fdh == NULL)
7077         return FALSE;
7078     }
7079
7080   /* We can't support overriding of symbols on a fake descriptor.  */
7081   if (fdh != NULL
7082       && fdh->fake
7083       && (fh->elf.root.type == bfd_link_hash_defined
7084           || fh->elf.root.type == bfd_link_hash_defweak))
7085     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7086
7087   /* Transfer dynamic linking information to the function descriptor.  */
7088   if (fdh != NULL)
7089     {
7090       fdh->elf.ref_regular |= fh->elf.ref_regular;
7091       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7092       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7093       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7094       fdh->elf.dynamic |= fh->elf.dynamic;
7095       fdh->elf.needs_plt |= (fh->elf.needs_plt
7096                              || fh->elf.type == STT_FUNC
7097                              || fh->elf.type == STT_GNU_IFUNC);
7098       move_plt_plist (fh, fdh);
7099
7100       if (!fdh->elf.forced_local
7101           && fh->elf.dynindx != -1)
7102         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7103           return FALSE;
7104     }
7105
7106   /* Now that the info is on the function descriptor, clear the
7107      function code sym info.  Any function code syms for which we
7108      don't have a definition in a regular file, we force local.
7109      This prevents a shared library from exporting syms that have
7110      been imported from another library.  Function code syms that
7111      are really in the library we must leave global to prevent the
7112      linker dragging in a definition from a static library.  */
7113   force_local = (!fh->elf.def_regular
7114                  || fdh == NULL
7115                  || !fdh->elf.def_regular
7116                  || fdh->elf.forced_local);
7117   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7118
7119   return TRUE;
7120 }
7121
7122 static const struct sfpr_def_parms save_res_funcs[] =
7123   {
7124     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7125     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7126     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7127     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7128     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7129     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7130     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7131     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7132     { "._savef", 14, 31, savefpr, savefpr1_tail },
7133     { "._restf", 14, 31, restfpr, restfpr1_tail },
7134     { "_savevr_", 20, 31, savevr, savevr_tail },
7135     { "_restvr_", 20, 31, restvr, restvr_tail }
7136   };
7137
7138 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7139    this hook to a) provide some gcc support functions, and b) transfer
7140    dynamic linking information gathered so far on function code symbol
7141    entries, to their corresponding function descriptor symbol entries.  */
7142
7143 static bfd_boolean
7144 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7145                             struct bfd_link_info *info)
7146 {
7147   struct ppc_link_hash_table *htab;
7148
7149   htab = ppc_hash_table (info);
7150   if (htab == NULL)
7151     return FALSE;
7152
7153   /* Provide any missing _save* and _rest* functions.  */
7154   if (htab->sfpr != NULL)
7155     {
7156       unsigned int i;
7157
7158       htab->sfpr->size = 0;
7159       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7160         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7161           return FALSE;
7162       if (htab->sfpr->size == 0)
7163         htab->sfpr->flags |= SEC_EXCLUDE;
7164     }
7165
7166   if (bfd_link_relocatable (info))
7167     return TRUE;
7168
7169   if (htab->elf.hgot != NULL)
7170     {
7171       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7172       /* Make .TOC. defined so as to prevent it being made dynamic.
7173          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7174       if (!htab->elf.hgot->def_regular
7175           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7176         {
7177           htab->elf.hgot->root.type = bfd_link_hash_defined;
7178           htab->elf.hgot->root.u.def.value = 0;
7179           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7180           htab->elf.hgot->def_regular = 1;
7181           htab->elf.hgot->root.linker_def = 1;
7182         }
7183       htab->elf.hgot->type = STT_OBJECT;
7184       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7185                                | STV_HIDDEN);
7186     }
7187
7188   if (htab->need_func_desc_adj)
7189     {
7190       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7191       htab->need_func_desc_adj = 0;
7192     }
7193
7194   return TRUE;
7195 }
7196
7197 /* Return true if we have dynamic relocs against H that apply to
7198    read-only sections.  */
7199
7200 static bfd_boolean
7201 readonly_dynrelocs (struct elf_link_hash_entry *h)
7202 {
7203   struct ppc_link_hash_entry *eh;
7204   struct elf_dyn_relocs *p;
7205
7206   eh = (struct ppc_link_hash_entry *) h;
7207   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7208     {
7209       asection *s = p->sec->output_section;
7210
7211       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7212         return TRUE;
7213     }
7214   return FALSE;
7215 }
7216
7217 /* Return true if we have dynamic relocs against H or any of its weak
7218    aliases, that apply to read-only sections.  */
7219
7220 static bfd_boolean
7221 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7222 {
7223   struct ppc_link_hash_entry *eh;
7224
7225   eh = (struct ppc_link_hash_entry *) h;
7226   do
7227     {
7228       if (readonly_dynrelocs (&eh->elf))
7229         return TRUE;
7230       eh = eh->weakref;
7231     } while (eh != NULL && &eh->elf != h);
7232
7233   return FALSE;
7234 }
7235
7236 /* Return whether EH has pc-relative dynamic relocs.  */
7237
7238 static bfd_boolean
7239 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7240 {
7241   struct elf_dyn_relocs *p;
7242
7243   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7244     if (p->pc_count != 0)
7245       return TRUE;
7246   return FALSE;
7247 }
7248
7249 /* Return true if a global entry stub will be created for H.  Valid
7250    for ELFv2 before plt entries have been allocated.  */
7251
7252 static bfd_boolean
7253 global_entry_stub (struct elf_link_hash_entry *h)
7254 {
7255   struct plt_entry *pent;
7256
7257   if (!h->pointer_equality_needed
7258       || h->def_regular)
7259     return FALSE;
7260
7261   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7262     if (pent->plt.refcount > 0
7263         && pent->addend == 0)
7264       return TRUE;
7265
7266   return FALSE;
7267 }
7268
7269 /* Adjust a symbol defined by a dynamic object and referenced by a
7270    regular object.  The current definition is in some section of the
7271    dynamic object, but we're not including those sections.  We have to
7272    change the definition to something the rest of the link can
7273    understand.  */
7274
7275 static bfd_boolean
7276 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7277                                  struct elf_link_hash_entry *h)
7278 {
7279   struct ppc_link_hash_table *htab;
7280   asection *s, *srel;
7281
7282   htab = ppc_hash_table (info);
7283   if (htab == NULL)
7284     return FALSE;
7285
7286   /* Deal with function syms.  */
7287   if (h->type == STT_FUNC
7288       || h->type == STT_GNU_IFUNC
7289       || h->needs_plt)
7290     {
7291       /* Clear procedure linkage table information for any symbol that
7292          won't need a .plt entry.  */
7293       struct plt_entry *ent;
7294       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7295         if (ent->plt.refcount > 0)
7296           break;
7297       if (ent == NULL
7298           || (h->type != STT_GNU_IFUNC
7299               && (SYMBOL_CALLS_LOCAL (info, h)
7300                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7301                       && h->root.type == bfd_link_hash_undefweak)))
7302           || ((struct ppc_link_hash_entry *) h)->save_res)
7303         {
7304           h->plt.plist = NULL;
7305           h->needs_plt = 0;
7306           h->pointer_equality_needed = 0;
7307         }
7308       else if (abiversion (info->output_bfd) >= 2)
7309         {
7310           /* Taking a function's address in a read/write section
7311              doesn't require us to define the function symbol in the
7312              executable on a global entry stub.  A dynamic reloc can
7313              be used instead.  The reason we prefer a few more dynamic
7314              relocs is that calling via a global entry stub costs a
7315              few more instructions, and pointer_equality_needed causes
7316              extra work in ld.so when resolving these symbols.  */
7317           if (global_entry_stub (h)
7318               && !alias_readonly_dynrelocs (h))
7319             {
7320               h->pointer_equality_needed = 0;
7321               /* After adjust_dynamic_symbol, non_got_ref set in
7322                  the non-pic case means that dyn_relocs for this
7323                  symbol should be discarded.  */
7324               h->non_got_ref = 0;
7325             }
7326
7327           /* If making a plt entry, then we don't need copy relocs.  */
7328           return TRUE;
7329         }
7330     }
7331   else
7332     h->plt.plist = NULL;
7333
7334   /* If this is a weak symbol, and there is a real definition, the
7335      processor independent code will have arranged for us to see the
7336      real definition first, and we can just use the same value.  */
7337   if (h->u.weakdef != NULL)
7338     {
7339       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7340                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7341       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7342       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7343       if (ELIMINATE_COPY_RELOCS)
7344         h->non_got_ref = h->u.weakdef->non_got_ref;
7345       return TRUE;
7346     }
7347
7348   /* If we are creating a shared library, we must presume that the
7349      only references to the symbol are via the global offset table.
7350      For such cases we need not do anything here; the relocations will
7351      be handled correctly by relocate_section.  */
7352   if (bfd_link_pic (info))
7353     return TRUE;
7354
7355   /* If there are no references to this symbol that do not use the
7356      GOT, we don't need to generate a copy reloc.  */
7357   if (!h->non_got_ref)
7358     return TRUE;
7359
7360   /* Don't generate a copy reloc for symbols defined in the executable.  */
7361   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7362
7363       /* If -z nocopyreloc was given, don't generate them either.  */
7364       || info->nocopyreloc
7365
7366       /* If we didn't find any dynamic relocs in read-only sections, then
7367          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7368       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7369
7370       /* Protected variables do not work with .dynbss.  The copy in
7371          .dynbss won't be used by the shared library with the protected
7372          definition for the variable.  Text relocations are preferable
7373          to an incorrect program.  */
7374       || h->protected_def)
7375     {
7376       h->non_got_ref = 0;
7377       return TRUE;
7378     }
7379
7380   if (h->plt.plist != NULL)
7381     {
7382       /* We should never get here, but unfortunately there are versions
7383          of gcc out there that improperly (for this ABI) put initialized
7384          function pointers, vtable refs and suchlike in read-only
7385          sections.  Allow them to proceed, but warn that this might
7386          break at runtime.  */
7387       info->callbacks->einfo
7388         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7389            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7390          h->root.root.string);
7391     }
7392
7393   /* This is a reference to a symbol defined by a dynamic object which
7394      is not a function.  */
7395
7396   /* We must allocate the symbol in our .dynbss section, which will
7397      become part of the .bss section of the executable.  There will be
7398      an entry for this symbol in the .dynsym section.  The dynamic
7399      object will contain position independent code, so all references
7400      from the dynamic object to this symbol will go through the global
7401      offset table.  The dynamic linker will use the .dynsym entry to
7402      determine the address it must put in the global offset table, so
7403      both the dynamic object and the regular object will refer to the
7404      same memory location for the variable.  */
7405
7406   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7407      to copy the initial value out of the dynamic object and into the
7408      runtime process image.  We need to remember the offset into the
7409      .rela.bss section we are going to use.  */
7410   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7411     {
7412       s = htab->elf.sdynrelro;
7413       srel = htab->elf.sreldynrelro;
7414     }
7415   else
7416     {
7417       s = htab->elf.sdynbss;
7418       srel = htab->elf.srelbss;
7419     }
7420   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7421     {
7422       srel->size += sizeof (Elf64_External_Rela);
7423       h->needs_copy = 1;
7424     }
7425
7426   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7427 }
7428
7429 /* If given a function descriptor symbol, hide both the function code
7430    sym and the descriptor.  */
7431 static void
7432 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7433                        struct elf_link_hash_entry *h,
7434                        bfd_boolean force_local)
7435 {
7436   struct ppc_link_hash_entry *eh;
7437   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7438
7439   eh = (struct ppc_link_hash_entry *) h;
7440   if (eh->is_func_descriptor)
7441     {
7442       struct ppc_link_hash_entry *fh = eh->oh;
7443
7444       if (fh == NULL)
7445         {
7446           const char *p, *q;
7447           struct elf_link_hash_table *htab = elf_hash_table (info);
7448           char save;
7449
7450           /* We aren't supposed to use alloca in BFD because on
7451              systems which do not have alloca the version in libiberty
7452              calls xmalloc, which might cause the program to crash
7453              when it runs out of memory.  This function doesn't have a
7454              return status, so there's no way to gracefully return an
7455              error.  So cheat.  We know that string[-1] can be safely
7456              accessed;  It's either a string in an ELF string table,
7457              or allocated in an objalloc structure.  */
7458
7459           p = eh->elf.root.root.string - 1;
7460           save = *p;
7461           *(char *) p = '.';
7462           fh = (struct ppc_link_hash_entry *)
7463             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7464           *(char *) p = save;
7465
7466           /* Unfortunately, if it so happens that the string we were
7467              looking for was allocated immediately before this string,
7468              then we overwrote the string terminator.  That's the only
7469              reason the lookup should fail.  */
7470           if (fh == NULL)
7471             {
7472               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7473               while (q >= eh->elf.root.root.string && *q == *p)
7474                 --q, --p;
7475               if (q < eh->elf.root.root.string && *p == '.')
7476                 fh = (struct ppc_link_hash_entry *)
7477                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7478             }
7479           if (fh != NULL)
7480             {
7481               eh->oh = fh;
7482               fh->oh = eh;
7483             }
7484         }
7485       if (fh != NULL)
7486         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7487     }
7488 }
7489
7490 static bfd_boolean
7491 get_sym_h (struct elf_link_hash_entry **hp,
7492            Elf_Internal_Sym **symp,
7493            asection **symsecp,
7494            unsigned char **tls_maskp,
7495            Elf_Internal_Sym **locsymsp,
7496            unsigned long r_symndx,
7497            bfd *ibfd)
7498 {
7499   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7500
7501   if (r_symndx >= symtab_hdr->sh_info)
7502     {
7503       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7504       struct elf_link_hash_entry *h;
7505
7506       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7507       h = elf_follow_link (h);
7508
7509       if (hp != NULL)
7510         *hp = h;
7511
7512       if (symp != NULL)
7513         *symp = NULL;
7514
7515       if (symsecp != NULL)
7516         {
7517           asection *symsec = NULL;
7518           if (h->root.type == bfd_link_hash_defined
7519               || h->root.type == bfd_link_hash_defweak)
7520             symsec = h->root.u.def.section;
7521           *symsecp = symsec;
7522         }
7523
7524       if (tls_maskp != NULL)
7525         {
7526           struct ppc_link_hash_entry *eh;
7527
7528           eh = (struct ppc_link_hash_entry *) h;
7529           *tls_maskp = &eh->tls_mask;
7530         }
7531     }
7532   else
7533     {
7534       Elf_Internal_Sym *sym;
7535       Elf_Internal_Sym *locsyms = *locsymsp;
7536
7537       if (locsyms == NULL)
7538         {
7539           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7540           if (locsyms == NULL)
7541             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7542                                             symtab_hdr->sh_info,
7543                                             0, NULL, NULL, NULL);
7544           if (locsyms == NULL)
7545             return FALSE;
7546           *locsymsp = locsyms;
7547         }
7548       sym = locsyms + r_symndx;
7549
7550       if (hp != NULL)
7551         *hp = NULL;
7552
7553       if (symp != NULL)
7554         *symp = sym;
7555
7556       if (symsecp != NULL)
7557         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7558
7559       if (tls_maskp != NULL)
7560         {
7561           struct got_entry **lgot_ents;
7562           unsigned char *tls_mask;
7563
7564           tls_mask = NULL;
7565           lgot_ents = elf_local_got_ents (ibfd);
7566           if (lgot_ents != NULL)
7567             {
7568               struct plt_entry **local_plt = (struct plt_entry **)
7569                 (lgot_ents + symtab_hdr->sh_info);
7570               unsigned char *lgot_masks = (unsigned char *)
7571                 (local_plt + symtab_hdr->sh_info);
7572               tls_mask = &lgot_masks[r_symndx];
7573             }
7574           *tls_maskp = tls_mask;
7575         }
7576     }
7577   return TRUE;
7578 }
7579
7580 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7581    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7582    type suitable for optimization, and 1 otherwise.  */
7583
7584 static int
7585 get_tls_mask (unsigned char **tls_maskp,
7586               unsigned long *toc_symndx,
7587               bfd_vma *toc_addend,
7588               Elf_Internal_Sym **locsymsp,
7589               const Elf_Internal_Rela *rel,
7590               bfd *ibfd)
7591 {
7592   unsigned long r_symndx;
7593   int next_r;
7594   struct elf_link_hash_entry *h;
7595   Elf_Internal_Sym *sym;
7596   asection *sec;
7597   bfd_vma off;
7598
7599   r_symndx = ELF64_R_SYM (rel->r_info);
7600   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7601     return 0;
7602
7603   if ((*tls_maskp != NULL && **tls_maskp != 0)
7604       || sec == NULL
7605       || ppc64_elf_section_data (sec) == NULL
7606       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7607     return 1;
7608
7609   /* Look inside a TOC section too.  */
7610   if (h != NULL)
7611     {
7612       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7613       off = h->root.u.def.value;
7614     }
7615   else
7616     off = sym->st_value;
7617   off += rel->r_addend;
7618   BFD_ASSERT (off % 8 == 0);
7619   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7620   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7621   if (toc_symndx != NULL)
7622     *toc_symndx = r_symndx;
7623   if (toc_addend != NULL)
7624     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7625   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7626     return 0;
7627   if ((h == NULL || is_static_defined (h))
7628       && (next_r == -1 || next_r == -2))
7629     return 1 - next_r;
7630   return 1;
7631 }
7632
7633 /* Find (or create) an entry in the tocsave hash table.  */
7634
7635 static struct tocsave_entry *
7636 tocsave_find (struct ppc_link_hash_table *htab,
7637               enum insert_option insert,
7638               Elf_Internal_Sym **local_syms,
7639               const Elf_Internal_Rela *irela,
7640               bfd *ibfd)
7641 {
7642   unsigned long r_indx;
7643   struct elf_link_hash_entry *h;
7644   Elf_Internal_Sym *sym;
7645   struct tocsave_entry ent, *p;
7646   hashval_t hash;
7647   struct tocsave_entry **slot;
7648
7649   r_indx = ELF64_R_SYM (irela->r_info);
7650   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7651     return NULL;
7652   if (ent.sec == NULL || ent.sec->output_section == NULL)
7653     {
7654       _bfd_error_handler
7655         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7656       return NULL;
7657     }
7658
7659   if (h != NULL)
7660     ent.offset = h->root.u.def.value;
7661   else
7662     ent.offset = sym->st_value;
7663   ent.offset += irela->r_addend;
7664
7665   hash = tocsave_htab_hash (&ent);
7666   slot = ((struct tocsave_entry **)
7667           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7668   if (slot == NULL)
7669     return NULL;
7670
7671   if (*slot == NULL)
7672     {
7673       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7674       if (p == NULL)
7675         return NULL;
7676       *p = ent;
7677       *slot = p;
7678     }
7679   return *slot;
7680 }
7681
7682 /* Adjust all global syms defined in opd sections.  In gcc generated
7683    code for the old ABI, these will already have been done.  */
7684
7685 static bfd_boolean
7686 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7687 {
7688   struct ppc_link_hash_entry *eh;
7689   asection *sym_sec;
7690   struct _opd_sec_data *opd;
7691
7692   if (h->root.type == bfd_link_hash_indirect)
7693     return TRUE;
7694
7695   if (h->root.type != bfd_link_hash_defined
7696       && h->root.type != bfd_link_hash_defweak)
7697     return TRUE;
7698
7699   eh = (struct ppc_link_hash_entry *) h;
7700   if (eh->adjust_done)
7701     return TRUE;
7702
7703   sym_sec = eh->elf.root.u.def.section;
7704   opd = get_opd_info (sym_sec);
7705   if (opd != NULL && opd->adjust != NULL)
7706     {
7707       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7708       if (adjust == -1)
7709         {
7710           /* This entry has been deleted.  */
7711           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7712           if (dsec == NULL)
7713             {
7714               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7715                 if (discarded_section (dsec))
7716                   {
7717                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7718                     break;
7719                   }
7720             }
7721           eh->elf.root.u.def.value = 0;
7722           eh->elf.root.u.def.section = dsec;
7723         }
7724       else
7725         eh->elf.root.u.def.value += adjust;
7726       eh->adjust_done = 1;
7727     }
7728   return TRUE;
7729 }
7730
7731 /* Handles decrementing dynamic reloc counts for the reloc specified by
7732    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7733    have already been determined.  */
7734
7735 static bfd_boolean
7736 dec_dynrel_count (bfd_vma r_info,
7737                   asection *sec,
7738                   struct bfd_link_info *info,
7739                   Elf_Internal_Sym **local_syms,
7740                   struct elf_link_hash_entry *h,
7741                   Elf_Internal_Sym *sym)
7742 {
7743   enum elf_ppc64_reloc_type r_type;
7744   asection *sym_sec = NULL;
7745
7746   /* Can this reloc be dynamic?  This switch, and later tests here
7747      should be kept in sync with the code in check_relocs.  */
7748   r_type = ELF64_R_TYPE (r_info);
7749   switch (r_type)
7750     {
7751     default:
7752       return TRUE;
7753
7754     case R_PPC64_TPREL16:
7755     case R_PPC64_TPREL16_LO:
7756     case R_PPC64_TPREL16_HI:
7757     case R_PPC64_TPREL16_HA:
7758     case R_PPC64_TPREL16_DS:
7759     case R_PPC64_TPREL16_LO_DS:
7760     case R_PPC64_TPREL16_HIGH:
7761     case R_PPC64_TPREL16_HIGHA:
7762     case R_PPC64_TPREL16_HIGHER:
7763     case R_PPC64_TPREL16_HIGHERA:
7764     case R_PPC64_TPREL16_HIGHEST:
7765     case R_PPC64_TPREL16_HIGHESTA:
7766       if (!bfd_link_pic (info))
7767         return TRUE;
7768
7769     case R_PPC64_TPREL64:
7770     case R_PPC64_DTPMOD64:
7771     case R_PPC64_DTPREL64:
7772     case R_PPC64_ADDR64:
7773     case R_PPC64_REL30:
7774     case R_PPC64_REL32:
7775     case R_PPC64_REL64:
7776     case R_PPC64_ADDR14:
7777     case R_PPC64_ADDR14_BRNTAKEN:
7778     case R_PPC64_ADDR14_BRTAKEN:
7779     case R_PPC64_ADDR16:
7780     case R_PPC64_ADDR16_DS:
7781     case R_PPC64_ADDR16_HA:
7782     case R_PPC64_ADDR16_HI:
7783     case R_PPC64_ADDR16_HIGH:
7784     case R_PPC64_ADDR16_HIGHA:
7785     case R_PPC64_ADDR16_HIGHER:
7786     case R_PPC64_ADDR16_HIGHERA:
7787     case R_PPC64_ADDR16_HIGHEST:
7788     case R_PPC64_ADDR16_HIGHESTA:
7789     case R_PPC64_ADDR16_LO:
7790     case R_PPC64_ADDR16_LO_DS:
7791     case R_PPC64_ADDR24:
7792     case R_PPC64_ADDR32:
7793     case R_PPC64_UADDR16:
7794     case R_PPC64_UADDR32:
7795     case R_PPC64_UADDR64:
7796     case R_PPC64_TOC:
7797       break;
7798     }
7799
7800   if (local_syms != NULL)
7801     {
7802       unsigned long r_symndx;
7803       bfd *ibfd = sec->owner;
7804
7805       r_symndx = ELF64_R_SYM (r_info);
7806       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7807         return FALSE;
7808     }
7809
7810   if ((bfd_link_pic (info)
7811        && (must_be_dyn_reloc (info, r_type)
7812            || (h != NULL
7813                && (!SYMBOLIC_BIND (info, h)
7814                    || h->root.type == bfd_link_hash_defweak
7815                    || !h->def_regular))))
7816       || (ELIMINATE_COPY_RELOCS
7817           && !bfd_link_pic (info)
7818           && h != NULL
7819           && (h->root.type == bfd_link_hash_defweak
7820               || !h->def_regular)))
7821     ;
7822   else
7823     return TRUE;
7824
7825   if (h != NULL)
7826     {
7827       struct elf_dyn_relocs *p;
7828       struct elf_dyn_relocs **pp;
7829       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7830
7831       /* elf_gc_sweep may have already removed all dyn relocs associated
7832          with local syms for a given section.  Also, symbol flags are
7833          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7834          report a dynreloc miscount.  */
7835       if (*pp == NULL && info->gc_sections)
7836         return TRUE;
7837
7838       while ((p = *pp) != NULL)
7839         {
7840           if (p->sec == sec)
7841             {
7842               if (!must_be_dyn_reloc (info, r_type))
7843                 p->pc_count -= 1;
7844               p->count -= 1;
7845               if (p->count == 0)
7846                 *pp = p->next;
7847               return TRUE;
7848             }
7849           pp = &p->next;
7850         }
7851     }
7852   else
7853     {
7854       struct ppc_dyn_relocs *p;
7855       struct ppc_dyn_relocs **pp;
7856       void *vpp;
7857       bfd_boolean is_ifunc;
7858
7859       if (local_syms == NULL)
7860         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7861       if (sym_sec == NULL)
7862         sym_sec = sec;
7863
7864       vpp = &elf_section_data (sym_sec)->local_dynrel;
7865       pp = (struct ppc_dyn_relocs **) vpp;
7866
7867       if (*pp == NULL && info->gc_sections)
7868         return TRUE;
7869
7870       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7871       while ((p = *pp) != NULL)
7872         {
7873           if (p->sec == sec && p->ifunc == is_ifunc)
7874             {
7875               p->count -= 1;
7876               if (p->count == 0)
7877                 *pp = p->next;
7878               return TRUE;
7879             }
7880           pp = &p->next;
7881         }
7882     }
7883
7884   /* xgettext:c-format */
7885   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7886                           sec->owner, sec);
7887   bfd_set_error (bfd_error_bad_value);
7888   return FALSE;
7889 }
7890
7891 /* Remove unused Official Procedure Descriptor entries.  Currently we
7892    only remove those associated with functions in discarded link-once
7893    sections, or weakly defined functions that have been overridden.  It
7894    would be possible to remove many more entries for statically linked
7895    applications.  */
7896
7897 bfd_boolean
7898 ppc64_elf_edit_opd (struct bfd_link_info *info)
7899 {
7900   bfd *ibfd;
7901   bfd_boolean some_edited = FALSE;
7902   asection *need_pad = NULL;
7903   struct ppc_link_hash_table *htab;
7904
7905   htab = ppc_hash_table (info);
7906   if (htab == NULL)
7907     return FALSE;
7908
7909   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7910     {
7911       asection *sec;
7912       Elf_Internal_Rela *relstart, *rel, *relend;
7913       Elf_Internal_Shdr *symtab_hdr;
7914       Elf_Internal_Sym *local_syms;
7915       struct _opd_sec_data *opd;
7916       bfd_boolean need_edit, add_aux_fields, broken;
7917       bfd_size_type cnt_16b = 0;
7918
7919       if (!is_ppc64_elf (ibfd))
7920         continue;
7921
7922       sec = bfd_get_section_by_name (ibfd, ".opd");
7923       if (sec == NULL || sec->size == 0)
7924         continue;
7925
7926       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7927         continue;
7928
7929       if (sec->output_section == bfd_abs_section_ptr)
7930         continue;
7931
7932       /* Look through the section relocs.  */
7933       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7934         continue;
7935
7936       local_syms = NULL;
7937       symtab_hdr = &elf_symtab_hdr (ibfd);
7938
7939       /* Read the relocations.  */
7940       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7941                                             info->keep_memory);
7942       if (relstart == NULL)
7943         return FALSE;
7944
7945       /* First run through the relocs to check they are sane, and to
7946          determine whether we need to edit this opd section.  */
7947       need_edit = FALSE;
7948       broken = FALSE;
7949       need_pad = sec;
7950       relend = relstart + sec->reloc_count;
7951       for (rel = relstart; rel < relend; )
7952         {
7953           enum elf_ppc64_reloc_type r_type;
7954           unsigned long r_symndx;
7955           asection *sym_sec;
7956           struct elf_link_hash_entry *h;
7957           Elf_Internal_Sym *sym;
7958           bfd_vma offset;
7959
7960           /* .opd contains an array of 16 or 24 byte entries.  We're
7961              only interested in the reloc pointing to a function entry
7962              point.  */
7963           offset = rel->r_offset;
7964           if (rel + 1 == relend
7965               || rel[1].r_offset != offset + 8)
7966             {
7967               /* If someone messes with .opd alignment then after a
7968                  "ld -r" we might have padding in the middle of .opd.
7969                  Also, there's nothing to prevent someone putting
7970                  something silly in .opd with the assembler.  No .opd
7971                  optimization for them!  */
7972             broken_opd:
7973               _bfd_error_handler
7974                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7975               broken = TRUE;
7976               break;
7977             }
7978
7979           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7980               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7981             {
7982               _bfd_error_handler
7983                 /* xgettext:c-format */
7984                 (_("%B: unexpected reloc type %u in .opd section"),
7985                  ibfd, r_type);
7986               broken = TRUE;
7987               break;
7988             }
7989
7990           r_symndx = ELF64_R_SYM (rel->r_info);
7991           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7992                           r_symndx, ibfd))
7993             goto error_ret;
7994
7995           if (sym_sec == NULL || sym_sec->owner == NULL)
7996             {
7997               const char *sym_name;
7998               if (h != NULL)
7999                 sym_name = h->root.root.string;
8000               else
8001                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8002                                              sym_sec);
8003
8004               _bfd_error_handler
8005                 /* xgettext:c-format */
8006                 (_("%B: undefined sym `%s' in .opd section"),
8007                  ibfd, sym_name);
8008               broken = TRUE;
8009               break;
8010             }
8011
8012           /* opd entries are always for functions defined in the
8013              current input bfd.  If the symbol isn't defined in the
8014              input bfd, then we won't be using the function in this
8015              bfd;  It must be defined in a linkonce section in another
8016              bfd, or is weak.  It's also possible that we are
8017              discarding the function due to a linker script /DISCARD/,
8018              which we test for via the output_section.  */
8019           if (sym_sec->owner != ibfd
8020               || sym_sec->output_section == bfd_abs_section_ptr)
8021             need_edit = TRUE;
8022
8023           rel += 2;
8024           if (rel + 1 == relend
8025               || (rel + 2 < relend
8026                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8027             ++rel;
8028
8029           if (rel == relend)
8030             {
8031               if (sec->size == offset + 24)
8032                 {
8033                   need_pad = NULL;
8034                   break;
8035                 }
8036               if (sec->size == offset + 16)
8037                 {
8038                   cnt_16b++;
8039                   break;
8040                 }
8041               goto broken_opd;
8042             }
8043           else if (rel + 1 < relend
8044                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8045                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8046             {
8047               if (rel[0].r_offset == offset + 16)
8048                 cnt_16b++;
8049               else if (rel[0].r_offset != offset + 24)
8050                 goto broken_opd;
8051             }
8052           else
8053             goto broken_opd;
8054         }
8055
8056       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8057
8058       if (!broken && (need_edit || add_aux_fields))
8059         {
8060           Elf_Internal_Rela *write_rel;
8061           Elf_Internal_Shdr *rel_hdr;
8062           bfd_byte *rptr, *wptr;
8063           bfd_byte *new_contents;
8064           bfd_size_type amt;
8065
8066           new_contents = NULL;
8067           amt = OPD_NDX (sec->size) * sizeof (long);
8068           opd = &ppc64_elf_section_data (sec)->u.opd;
8069           opd->adjust = bfd_zalloc (sec->owner, amt);
8070           if (opd->adjust == NULL)
8071             return FALSE;
8072           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8073
8074           /* This seems a waste of time as input .opd sections are all
8075              zeros as generated by gcc, but I suppose there's no reason
8076              this will always be so.  We might start putting something in
8077              the third word of .opd entries.  */
8078           if ((sec->flags & SEC_IN_MEMORY) == 0)
8079             {
8080               bfd_byte *loc;
8081               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8082                 {
8083                   if (loc != NULL)
8084                     free (loc);
8085                 error_ret:
8086                   if (local_syms != NULL
8087                       && symtab_hdr->contents != (unsigned char *) local_syms)
8088                     free (local_syms);
8089                   if (elf_section_data (sec)->relocs != relstart)
8090                     free (relstart);
8091                   return FALSE;
8092                 }
8093               sec->contents = loc;
8094               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8095             }
8096
8097           elf_section_data (sec)->relocs = relstart;
8098
8099           new_contents = sec->contents;
8100           if (add_aux_fields)
8101             {
8102               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8103               if (new_contents == NULL)
8104                 return FALSE;
8105               need_pad = NULL;
8106             }
8107           wptr = new_contents;
8108           rptr = sec->contents;
8109           write_rel = relstart;
8110           for (rel = relstart; rel < relend; )
8111             {
8112               unsigned long r_symndx;
8113               asection *sym_sec;
8114               struct elf_link_hash_entry *h;
8115               struct ppc_link_hash_entry *fdh = NULL;
8116               Elf_Internal_Sym *sym;
8117               long opd_ent_size;
8118               Elf_Internal_Rela *next_rel;
8119               bfd_boolean skip;
8120
8121               r_symndx = ELF64_R_SYM (rel->r_info);
8122               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8123                               r_symndx, ibfd))
8124                 goto error_ret;
8125
8126               next_rel = rel + 2;
8127               if (next_rel + 1 == relend
8128                   || (next_rel + 2 < relend
8129                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8130                 ++next_rel;
8131
8132               /* See if the .opd entry is full 24 byte or
8133                  16 byte (with fd_aux entry overlapped with next
8134                  fd_func).  */
8135               opd_ent_size = 24;
8136               if (next_rel == relend)
8137                 {
8138                   if (sec->size == rel->r_offset + 16)
8139                     opd_ent_size = 16;
8140                 }
8141               else if (next_rel->r_offset == rel->r_offset + 16)
8142                 opd_ent_size = 16;
8143
8144               if (h != NULL
8145                   && h->root.root.string[0] == '.')
8146                 {
8147                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8148                   if (fdh != NULL)
8149                     {
8150                       fdh = ppc_follow_link (fdh);
8151                       if (fdh->elf.root.type != bfd_link_hash_defined
8152                           && fdh->elf.root.type != bfd_link_hash_defweak)
8153                         fdh = NULL;
8154                     }
8155                 }
8156
8157               skip = (sym_sec->owner != ibfd
8158                       || sym_sec->output_section == bfd_abs_section_ptr);
8159               if (skip)
8160                 {
8161                   if (fdh != NULL && sym_sec->owner == ibfd)
8162                     {
8163                       /* Arrange for the function descriptor sym
8164                          to be dropped.  */
8165                       fdh->elf.root.u.def.value = 0;
8166                       fdh->elf.root.u.def.section = sym_sec;
8167                     }
8168                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8169
8170                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8171                     rel = next_rel;
8172                   else
8173                     while (1)
8174                       {
8175                         if (!dec_dynrel_count (rel->r_info, sec, info,
8176                                                NULL, h, sym))
8177                           goto error_ret;
8178
8179                         if (++rel == next_rel)
8180                           break;
8181
8182                         r_symndx = ELF64_R_SYM (rel->r_info);
8183                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8184                                         r_symndx, ibfd))
8185                           goto error_ret;
8186                       }
8187                 }
8188               else
8189                 {
8190                   /* We'll be keeping this opd entry.  */
8191                   long adjust;
8192
8193                   if (fdh != NULL)
8194                     {
8195                       /* Redefine the function descriptor symbol to
8196                          this location in the opd section.  It is
8197                          necessary to update the value here rather
8198                          than using an array of adjustments as we do
8199                          for local symbols, because various places
8200                          in the generic ELF code use the value
8201                          stored in u.def.value.  */
8202                       fdh->elf.root.u.def.value = wptr - new_contents;
8203                       fdh->adjust_done = 1;
8204                     }
8205
8206                   /* Local syms are a bit tricky.  We could
8207                      tweak them as they can be cached, but
8208                      we'd need to look through the local syms
8209                      for the function descriptor sym which we
8210                      don't have at the moment.  So keep an
8211                      array of adjustments.  */
8212                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8213                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8214
8215                   if (wptr != rptr)
8216                     memcpy (wptr, rptr, opd_ent_size);
8217                   wptr += opd_ent_size;
8218                   if (add_aux_fields && opd_ent_size == 16)
8219                     {
8220                       memset (wptr, '\0', 8);
8221                       wptr += 8;
8222                     }
8223
8224                   /* We need to adjust any reloc offsets to point to the
8225                      new opd entries.  */
8226                   for ( ; rel != next_rel; ++rel)
8227                     {
8228                       rel->r_offset += adjust;
8229                       if (write_rel != rel)
8230                         memcpy (write_rel, rel, sizeof (*rel));
8231                       ++write_rel;
8232                     }
8233                 }
8234
8235               rptr += opd_ent_size;
8236             }
8237
8238           sec->size = wptr - new_contents;
8239           sec->reloc_count = write_rel - relstart;
8240           if (add_aux_fields)
8241             {
8242               free (sec->contents);
8243               sec->contents = new_contents;
8244             }
8245
8246           /* Fudge the header size too, as this is used later in
8247              elf_bfd_final_link if we are emitting relocs.  */
8248           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8249           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8250           some_edited = TRUE;
8251         }
8252       else if (elf_section_data (sec)->relocs != relstart)
8253         free (relstart);
8254
8255       if (local_syms != NULL
8256           && symtab_hdr->contents != (unsigned char *) local_syms)
8257         {
8258           if (!info->keep_memory)
8259             free (local_syms);
8260           else
8261             symtab_hdr->contents = (unsigned char *) local_syms;
8262         }
8263     }
8264
8265   if (some_edited)
8266     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8267
8268   /* If we are doing a final link and the last .opd entry is just 16 byte
8269      long, add a 8 byte padding after it.  */
8270   if (need_pad != NULL && !bfd_link_relocatable (info))
8271     {
8272       bfd_byte *p;
8273
8274       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8275         {
8276           BFD_ASSERT (need_pad->size > 0);
8277
8278           p = bfd_malloc (need_pad->size + 8);
8279           if (p == NULL)
8280             return FALSE;
8281
8282           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8283                                           p, 0, need_pad->size))
8284             return FALSE;
8285
8286           need_pad->contents = p;
8287           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8288         }
8289       else
8290         {
8291           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8292           if (p == NULL)
8293             return FALSE;
8294
8295           need_pad->contents = p;
8296         }
8297
8298       memset (need_pad->contents + need_pad->size, 0, 8);
8299       need_pad->size += 8;
8300     }
8301
8302   return TRUE;
8303 }
8304
8305 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8306
8307 asection *
8308 ppc64_elf_tls_setup (struct bfd_link_info *info)
8309 {
8310   struct ppc_link_hash_table *htab;
8311
8312   htab = ppc_hash_table (info);
8313   if (htab == NULL)
8314     return NULL;
8315
8316   if (abiversion (info->output_bfd) == 1)
8317     htab->opd_abi = 1;
8318
8319   if (htab->params->no_multi_toc)
8320     htab->do_multi_toc = 0;
8321   else if (!htab->do_multi_toc)
8322     htab->params->no_multi_toc = 1;
8323
8324   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8325                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8326                                               FALSE, FALSE, TRUE));
8327   /* Move dynamic linking info to the function descriptor sym.  */
8328   if (htab->tls_get_addr != NULL)
8329     func_desc_adjust (&htab->tls_get_addr->elf, info);
8330   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8331                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8332                                                  FALSE, FALSE, TRUE));
8333   if (htab->params->tls_get_addr_opt)
8334     {
8335       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8336
8337       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8338                                   FALSE, FALSE, TRUE);
8339       if (opt != NULL)
8340         func_desc_adjust (opt, info);
8341       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8342                                      FALSE, FALSE, TRUE);
8343       if (opt_fd != NULL
8344           && (opt_fd->root.type == bfd_link_hash_defined
8345               || opt_fd->root.type == bfd_link_hash_defweak))
8346         {
8347           /* If glibc supports an optimized __tls_get_addr call stub,
8348              signalled by the presence of __tls_get_addr_opt, and we'll
8349              be calling __tls_get_addr via a plt call stub, then
8350              make __tls_get_addr point to __tls_get_addr_opt.  */
8351           tga_fd = &htab->tls_get_addr_fd->elf;
8352           if (htab->elf.dynamic_sections_created
8353               && tga_fd != NULL
8354               && (tga_fd->type == STT_FUNC
8355                   || tga_fd->needs_plt)
8356               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8357                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8358                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8359             {
8360               struct plt_entry *ent;
8361
8362               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8363                 if (ent->plt.refcount > 0)
8364                   break;
8365               if (ent != NULL)
8366                 {
8367                   tga_fd->root.type = bfd_link_hash_indirect;
8368                   tga_fd->root.u.i.link = &opt_fd->root;
8369                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8370                   opt_fd->mark = 1;
8371                   if (opt_fd->dynindx != -1)
8372                     {
8373                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8374                       opt_fd->dynindx = -1;
8375                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8376                                               opt_fd->dynstr_index);
8377                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8378                         return NULL;
8379                     }
8380                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8381                   tga = &htab->tls_get_addr->elf;
8382                   if (opt != NULL && tga != NULL)
8383                     {
8384                       tga->root.type = bfd_link_hash_indirect;
8385                       tga->root.u.i.link = &opt->root;
8386                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8387                       opt->mark = 1;
8388                       _bfd_elf_link_hash_hide_symbol (info, opt,
8389                                                       tga->forced_local);
8390                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8391                     }
8392                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8393                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8394                   if (htab->tls_get_addr != NULL)
8395                     {
8396                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8397                       htab->tls_get_addr->is_func = 1;
8398                     }
8399                 }
8400             }
8401         }
8402       else if (htab->params->tls_get_addr_opt < 0)
8403         htab->params->tls_get_addr_opt = 0;
8404     }
8405   return _bfd_elf_tls_setup (info->output_bfd, info);
8406 }
8407
8408 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8409    HASH1 or HASH2.  */
8410
8411 static bfd_boolean
8412 branch_reloc_hash_match (const bfd *ibfd,
8413                          const Elf_Internal_Rela *rel,
8414                          const struct ppc_link_hash_entry *hash1,
8415                          const struct ppc_link_hash_entry *hash2)
8416 {
8417   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8418   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8419   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8420
8421   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8422     {
8423       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8424       struct elf_link_hash_entry *h;
8425
8426       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8427       h = elf_follow_link (h);
8428       if (h == &hash1->elf || h == &hash2->elf)
8429         return TRUE;
8430     }
8431   return FALSE;
8432 }
8433
8434 /* Run through all the TLS relocs looking for optimization
8435    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8436    a preliminary section layout so that we know the TLS segment
8437    offsets.  We can't optimize earlier because some optimizations need
8438    to know the tp offset, and we need to optimize before allocating
8439    dynamic relocations.  */
8440
8441 bfd_boolean
8442 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8443 {
8444   bfd *ibfd;
8445   asection *sec;
8446   struct ppc_link_hash_table *htab;
8447   unsigned char *toc_ref;
8448   int pass;
8449
8450   if (!bfd_link_executable (info))
8451     return TRUE;
8452
8453   htab = ppc_hash_table (info);
8454   if (htab == NULL)
8455     return FALSE;
8456
8457   /* Make two passes over the relocs.  On the first pass, mark toc
8458      entries involved with tls relocs, and check that tls relocs
8459      involved in setting up a tls_get_addr call are indeed followed by
8460      such a call.  If they are not, we can't do any tls optimization.
8461      On the second pass twiddle tls_mask flags to notify
8462      relocate_section that optimization can be done, and adjust got
8463      and plt refcounts.  */
8464   toc_ref = NULL;
8465   for (pass = 0; pass < 2; ++pass)
8466     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8467       {
8468         Elf_Internal_Sym *locsyms = NULL;
8469         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8470
8471         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8472           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8473             {
8474               Elf_Internal_Rela *relstart, *rel, *relend;
8475               bfd_boolean found_tls_get_addr_arg = 0;
8476
8477               /* Read the relocations.  */
8478               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8479                                                     info->keep_memory);
8480               if (relstart == NULL)
8481                 {
8482                   free (toc_ref);
8483                   return FALSE;
8484                 }
8485
8486               relend = relstart + sec->reloc_count;
8487               for (rel = relstart; rel < relend; rel++)
8488                 {
8489                   enum elf_ppc64_reloc_type r_type;
8490                   unsigned long r_symndx;
8491                   struct elf_link_hash_entry *h;
8492                   Elf_Internal_Sym *sym;
8493                   asection *sym_sec;
8494                   unsigned char *tls_mask;
8495                   unsigned char tls_set, tls_clear, tls_type = 0;
8496                   bfd_vma value;
8497                   bfd_boolean ok_tprel, is_local;
8498                   long toc_ref_index = 0;
8499                   int expecting_tls_get_addr = 0;
8500                   bfd_boolean ret = FALSE;
8501
8502                   r_symndx = ELF64_R_SYM (rel->r_info);
8503                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8504                                   r_symndx, ibfd))
8505                     {
8506                     err_free_rel:
8507                       if (elf_section_data (sec)->relocs != relstart)
8508                         free (relstart);
8509                       if (toc_ref != NULL)
8510                         free (toc_ref);
8511                       if (locsyms != NULL
8512                           && (elf_symtab_hdr (ibfd).contents
8513                               != (unsigned char *) locsyms))
8514                         free (locsyms);
8515                       return ret;
8516                     }
8517
8518                   if (h != NULL)
8519                     {
8520                       if (h->root.type == bfd_link_hash_defined
8521                           || h->root.type == bfd_link_hash_defweak)
8522                         value = h->root.u.def.value;
8523                       else if (h->root.type == bfd_link_hash_undefweak)
8524                         value = 0;
8525                       else
8526                         {
8527                           found_tls_get_addr_arg = 0;
8528                           continue;
8529                         }
8530                     }
8531                   else
8532                     /* Symbols referenced by TLS relocs must be of type
8533                        STT_TLS.  So no need for .opd local sym adjust.  */
8534                     value = sym->st_value;
8535
8536                   ok_tprel = FALSE;
8537                   is_local = FALSE;
8538                   if (h == NULL
8539                       || !h->def_dynamic)
8540                     {
8541                       is_local = TRUE;
8542                       if (h != NULL
8543                           && h->root.type == bfd_link_hash_undefweak)
8544                         ok_tprel = TRUE;
8545                       else if (sym_sec != NULL
8546                                && sym_sec->output_section != NULL)
8547                         {
8548                           value += sym_sec->output_offset;
8549                           value += sym_sec->output_section->vma;
8550                           value -= htab->elf.tls_sec->vma;
8551                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8552                                       < (bfd_vma) 1 << 32);
8553                         }
8554                     }
8555
8556                   r_type = ELF64_R_TYPE (rel->r_info);
8557                   /* If this section has old-style __tls_get_addr calls
8558                      without marker relocs, then check that each
8559                      __tls_get_addr call reloc is preceded by a reloc
8560                      that conceivably belongs to the __tls_get_addr arg
8561                      setup insn.  If we don't find matching arg setup
8562                      relocs, don't do any tls optimization.  */
8563                   if (pass == 0
8564                       && sec->has_tls_get_addr_call
8565                       && h != NULL
8566                       && (h == &htab->tls_get_addr->elf
8567                           || h == &htab->tls_get_addr_fd->elf)
8568                       && !found_tls_get_addr_arg
8569                       && is_branch_reloc (r_type))
8570                     {
8571                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8572                                                 "TLS optimization disabled\n"),
8573                                               ibfd, sec, rel->r_offset);
8574                       ret = TRUE;
8575                       goto err_free_rel;
8576                     }
8577
8578                   found_tls_get_addr_arg = 0;
8579                   switch (r_type)
8580                     {
8581                     case R_PPC64_GOT_TLSLD16:
8582                     case R_PPC64_GOT_TLSLD16_LO:
8583                       expecting_tls_get_addr = 1;
8584                       found_tls_get_addr_arg = 1;
8585                       /* Fall through.  */
8586
8587                     case R_PPC64_GOT_TLSLD16_HI:
8588                     case R_PPC64_GOT_TLSLD16_HA:
8589                       /* These relocs should never be against a symbol
8590                          defined in a shared lib.  Leave them alone if
8591                          that turns out to be the case.  */
8592                       if (!is_local)
8593                         continue;
8594
8595                       /* LD -> LE */
8596                       tls_set = 0;
8597                       tls_clear = TLS_LD;
8598                       tls_type = TLS_TLS | TLS_LD;
8599                       break;
8600
8601                     case R_PPC64_GOT_TLSGD16:
8602                     case R_PPC64_GOT_TLSGD16_LO:
8603                       expecting_tls_get_addr = 1;
8604                       found_tls_get_addr_arg = 1;
8605                       /* Fall through. */
8606
8607                     case R_PPC64_GOT_TLSGD16_HI:
8608                     case R_PPC64_GOT_TLSGD16_HA:
8609                       if (ok_tprel)
8610                         /* GD -> LE */
8611                         tls_set = 0;
8612                       else
8613                         /* GD -> IE */
8614                         tls_set = TLS_TLS | TLS_TPRELGD;
8615                       tls_clear = TLS_GD;
8616                       tls_type = TLS_TLS | TLS_GD;
8617                       break;
8618
8619                     case R_PPC64_GOT_TPREL16_DS:
8620                     case R_PPC64_GOT_TPREL16_LO_DS:
8621                     case R_PPC64_GOT_TPREL16_HI:
8622                     case R_PPC64_GOT_TPREL16_HA:
8623                       if (ok_tprel)
8624                         {
8625                           /* IE -> LE */
8626                           tls_set = 0;
8627                           tls_clear = TLS_TPREL;
8628                           tls_type = TLS_TLS | TLS_TPREL;
8629                           break;
8630                         }
8631                       continue;
8632
8633                     case R_PPC64_TLSGD:
8634                     case R_PPC64_TLSLD:
8635                       found_tls_get_addr_arg = 1;
8636                       /* Fall through.  */
8637
8638                     case R_PPC64_TLS:
8639                     case R_PPC64_TOC16:
8640                     case R_PPC64_TOC16_LO:
8641                       if (sym_sec == NULL || sym_sec != toc)
8642                         continue;
8643
8644                       /* Mark this toc entry as referenced by a TLS
8645                          code sequence.  We can do that now in the
8646                          case of R_PPC64_TLS, and after checking for
8647                          tls_get_addr for the TOC16 relocs.  */
8648                       if (toc_ref == NULL)
8649                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8650                       if (toc_ref == NULL)
8651                         goto err_free_rel;
8652
8653                       if (h != NULL)
8654                         value = h->root.u.def.value;
8655                       else
8656                         value = sym->st_value;
8657                       value += rel->r_addend;
8658                       if (value % 8 != 0)
8659                         continue;
8660                       BFD_ASSERT (value < toc->size
8661                                   && toc->output_offset % 8 == 0);
8662                       toc_ref_index = (value + toc->output_offset) / 8;
8663                       if (r_type == R_PPC64_TLS
8664                           || r_type == R_PPC64_TLSGD
8665                           || r_type == R_PPC64_TLSLD)
8666                         {
8667                           toc_ref[toc_ref_index] = 1;
8668                           continue;
8669                         }
8670
8671                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8672                         continue;
8673
8674                       tls_set = 0;
8675                       tls_clear = 0;
8676                       expecting_tls_get_addr = 2;
8677                       break;
8678
8679                     case R_PPC64_TPREL64:
8680                       if (pass == 0
8681                           || sec != toc
8682                           || toc_ref == NULL
8683                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8684                         continue;
8685                       if (ok_tprel)
8686                         {
8687                           /* IE -> LE */
8688                           tls_set = TLS_EXPLICIT;
8689                           tls_clear = TLS_TPREL;
8690                           break;
8691                         }
8692                       continue;
8693
8694                     case R_PPC64_DTPMOD64:
8695                       if (pass == 0
8696                           || sec != toc
8697                           || toc_ref == NULL
8698                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8699                         continue;
8700                       if (rel + 1 < relend
8701                           && (rel[1].r_info
8702                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8703                           && rel[1].r_offset == rel->r_offset + 8)
8704                         {
8705                           if (ok_tprel)
8706                             /* GD -> LE */
8707                             tls_set = TLS_EXPLICIT | TLS_GD;
8708                           else
8709                             /* GD -> IE */
8710                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8711                           tls_clear = TLS_GD;
8712                         }
8713                       else
8714                         {
8715                           if (!is_local)
8716                             continue;
8717
8718                           /* LD -> LE */
8719                           tls_set = TLS_EXPLICIT;
8720                           tls_clear = TLS_LD;
8721                         }
8722                       break;
8723
8724                     default:
8725                       continue;
8726                     }
8727
8728                   if (pass == 0)
8729                     {
8730                       if (!expecting_tls_get_addr
8731                           || !sec->has_tls_get_addr_call)
8732                         continue;
8733
8734                       if (rel + 1 < relend
8735                           && branch_reloc_hash_match (ibfd, rel + 1,
8736                                                       htab->tls_get_addr,
8737                                                       htab->tls_get_addr_fd))
8738                         {
8739                           if (expecting_tls_get_addr == 2)
8740                             {
8741                               /* Check for toc tls entries.  */
8742                               unsigned char *toc_tls;
8743                               int retval;
8744
8745                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8746                                                      &locsyms,
8747                                                      rel, ibfd);
8748                               if (retval == 0)
8749                                 goto err_free_rel;
8750                               if (toc_tls != NULL)
8751                                 {
8752                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8753                                     found_tls_get_addr_arg = 1;
8754                                   if (retval > 1)
8755                                     toc_ref[toc_ref_index] = 1;
8756                                 }
8757                             }
8758                           continue;
8759                         }
8760
8761                       if (expecting_tls_get_addr != 1)
8762                         continue;
8763
8764                       /* Uh oh, we didn't find the expected call.  We
8765                          could just mark this symbol to exclude it
8766                          from tls optimization but it's safer to skip
8767                          the entire optimization.  */
8768                       /* xgettext:c-format */
8769                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8770                                                 "TLS optimization disabled\n"),
8771                                               ibfd, sec, rel->r_offset);
8772                       ret = TRUE;
8773                       goto err_free_rel;
8774                     }
8775
8776                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8777                     {
8778                       struct plt_entry *ent;
8779                       for (ent = htab->tls_get_addr->elf.plt.plist;
8780                            ent != NULL;
8781                            ent = ent->next)
8782                         if (ent->addend == 0)
8783                           {
8784                             if (ent->plt.refcount > 0)
8785                               {
8786                                 ent->plt.refcount -= 1;
8787                                 expecting_tls_get_addr = 0;
8788                               }
8789                             break;
8790                           }
8791                     }
8792
8793                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8794                     {
8795                       struct plt_entry *ent;
8796                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8797                            ent != NULL;
8798                            ent = ent->next)
8799                         if (ent->addend == 0)
8800                           {
8801                             if (ent->plt.refcount > 0)
8802                               ent->plt.refcount -= 1;
8803                             break;
8804                           }
8805                     }
8806
8807                   if (tls_clear == 0)
8808                     continue;
8809
8810                   if ((tls_set & TLS_EXPLICIT) == 0)
8811                     {
8812                       struct got_entry *ent;
8813
8814                       /* Adjust got entry for this reloc.  */
8815                       if (h != NULL)
8816                         ent = h->got.glist;
8817                       else
8818                         ent = elf_local_got_ents (ibfd)[r_symndx];
8819
8820                       for (; ent != NULL; ent = ent->next)
8821                         if (ent->addend == rel->r_addend
8822                             && ent->owner == ibfd
8823                             && ent->tls_type == tls_type)
8824                           break;
8825                       if (ent == NULL)
8826                         abort ();
8827
8828                       if (tls_set == 0)
8829                         {
8830                           /* We managed to get rid of a got entry.  */
8831                           if (ent->got.refcount > 0)
8832                             ent->got.refcount -= 1;
8833                         }
8834                     }
8835                   else
8836                     {
8837                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8838                          we'll lose one or two dyn relocs.  */
8839                       if (!dec_dynrel_count (rel->r_info, sec, info,
8840                                              NULL, h, sym))
8841                         return FALSE;
8842
8843                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8844                         {
8845                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8846                                                  NULL, h, sym))
8847                             return FALSE;
8848                         }
8849                     }
8850
8851                   *tls_mask |= tls_set;
8852                   *tls_mask &= ~tls_clear;
8853                 }
8854
8855               if (elf_section_data (sec)->relocs != relstart)
8856                 free (relstart);
8857             }
8858
8859         if (locsyms != NULL
8860             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8861           {
8862             if (!info->keep_memory)
8863               free (locsyms);
8864             else
8865               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8866           }
8867       }
8868
8869   if (toc_ref != NULL)
8870     free (toc_ref);
8871   return TRUE;
8872 }
8873
8874 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8875    the values of any global symbols in a toc section that has been
8876    edited.  Globals in toc sections should be a rarity, so this function
8877    sets a flag if any are found in toc sections other than the one just
8878    edited, so that futher hash table traversals can be avoided.  */
8879
8880 struct adjust_toc_info
8881 {
8882   asection *toc;
8883   unsigned long *skip;
8884   bfd_boolean global_toc_syms;
8885 };
8886
8887 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8888
8889 static bfd_boolean
8890 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8891 {
8892   struct ppc_link_hash_entry *eh;
8893   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8894   unsigned long i;
8895
8896   if (h->root.type != bfd_link_hash_defined
8897       && h->root.type != bfd_link_hash_defweak)
8898     return TRUE;
8899
8900   eh = (struct ppc_link_hash_entry *) h;
8901   if (eh->adjust_done)
8902     return TRUE;
8903
8904   if (eh->elf.root.u.def.section == toc_inf->toc)
8905     {
8906       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8907         i = toc_inf->toc->rawsize >> 3;
8908       else
8909         i = eh->elf.root.u.def.value >> 3;
8910
8911       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8912         {
8913           _bfd_error_handler
8914             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8915           do
8916             ++i;
8917           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8918           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8919         }
8920
8921       eh->elf.root.u.def.value -= toc_inf->skip[i];
8922       eh->adjust_done = 1;
8923     }
8924   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8925     toc_inf->global_toc_syms = TRUE;
8926
8927   return TRUE;
8928 }
8929
8930 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8931    on a _LO variety toc/got reloc.  */
8932
8933 static bfd_boolean
8934 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8935 {
8936   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8937           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8938           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8939           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8940           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8941           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8942           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8943           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8944           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8945           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8946           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8947           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8948           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8949           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8950           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8951           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8952           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8953               /* Exclude lfqu by testing reloc.  If relocs are ever
8954                  defined for the reduced D field in psq_lu then those
8955                  will need testing too.  */
8956               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8957           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8958               && (insn & 1) == 0)
8959           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8960           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8961               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8962               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8963           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8964               && (insn & 1) == 0));
8965 }
8966
8967 /* Examine all relocs referencing .toc sections in order to remove
8968    unused .toc entries.  */
8969
8970 bfd_boolean
8971 ppc64_elf_edit_toc (struct bfd_link_info *info)
8972 {
8973   bfd *ibfd;
8974   struct adjust_toc_info toc_inf;
8975   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8976
8977   htab->do_toc_opt = 1;
8978   toc_inf.global_toc_syms = TRUE;
8979   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8980     {
8981       asection *toc, *sec;
8982       Elf_Internal_Shdr *symtab_hdr;
8983       Elf_Internal_Sym *local_syms;
8984       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8985       unsigned long *skip, *drop;
8986       unsigned char *used;
8987       unsigned char *keep, last, some_unused;
8988
8989       if (!is_ppc64_elf (ibfd))
8990         continue;
8991
8992       toc = bfd_get_section_by_name (ibfd, ".toc");
8993       if (toc == NULL
8994           || toc->size == 0
8995           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8996           || discarded_section (toc))
8997         continue;
8998
8999       toc_relocs = NULL;
9000       local_syms = NULL;
9001       symtab_hdr = &elf_symtab_hdr (ibfd);
9002
9003       /* Look at sections dropped from the final link.  */
9004       skip = NULL;
9005       relstart = NULL;
9006       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9007         {
9008           if (sec->reloc_count == 0
9009               || !discarded_section (sec)
9010               || get_opd_info (sec)
9011               || (sec->flags & SEC_ALLOC) == 0
9012               || (sec->flags & SEC_DEBUGGING) != 0)
9013             continue;
9014
9015           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9016           if (relstart == NULL)
9017             goto error_ret;
9018
9019           /* Run through the relocs to see which toc entries might be
9020              unused.  */
9021           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9022             {
9023               enum elf_ppc64_reloc_type r_type;
9024               unsigned long r_symndx;
9025               asection *sym_sec;
9026               struct elf_link_hash_entry *h;
9027               Elf_Internal_Sym *sym;
9028               bfd_vma val;
9029
9030               r_type = ELF64_R_TYPE (rel->r_info);
9031               switch (r_type)
9032                 {
9033                 default:
9034                   continue;
9035
9036                 case R_PPC64_TOC16:
9037                 case R_PPC64_TOC16_LO:
9038                 case R_PPC64_TOC16_HI:
9039                 case R_PPC64_TOC16_HA:
9040                 case R_PPC64_TOC16_DS:
9041                 case R_PPC64_TOC16_LO_DS:
9042                   break;
9043                 }
9044
9045               r_symndx = ELF64_R_SYM (rel->r_info);
9046               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9047                               r_symndx, ibfd))
9048                 goto error_ret;
9049
9050               if (sym_sec != toc)
9051                 continue;
9052
9053               if (h != NULL)
9054                 val = h->root.u.def.value;
9055               else
9056                 val = sym->st_value;
9057               val += rel->r_addend;
9058
9059               if (val >= toc->size)
9060                 continue;
9061
9062               /* Anything in the toc ought to be aligned to 8 bytes.
9063                  If not, don't mark as unused.  */
9064               if (val & 7)
9065                 continue;
9066
9067               if (skip == NULL)
9068                 {
9069                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9070                   if (skip == NULL)
9071                     goto error_ret;
9072                 }
9073
9074               skip[val >> 3] = ref_from_discarded;
9075             }
9076
9077           if (elf_section_data (sec)->relocs != relstart)
9078             free (relstart);
9079         }
9080
9081       /* For largetoc loads of address constants, we can convert
9082          .  addis rx,2,addr@got@ha
9083          .  ld ry,addr@got@l(rx)
9084          to
9085          .  addis rx,2,addr@toc@ha
9086          .  addi ry,rx,addr@toc@l
9087          when addr is within 2G of the toc pointer.  This then means
9088          that the word storing "addr" in the toc is no longer needed.  */
9089
9090       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9091           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9092           && toc->reloc_count != 0)
9093         {
9094           /* Read toc relocs.  */
9095           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9096                                                   info->keep_memory);
9097           if (toc_relocs == NULL)
9098             goto error_ret;
9099
9100           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9101             {
9102               enum elf_ppc64_reloc_type r_type;
9103               unsigned long r_symndx;
9104               asection *sym_sec;
9105               struct elf_link_hash_entry *h;
9106               Elf_Internal_Sym *sym;
9107               bfd_vma val, addr;
9108
9109               r_type = ELF64_R_TYPE (rel->r_info);
9110               if (r_type != R_PPC64_ADDR64)
9111                 continue;
9112
9113               r_symndx = ELF64_R_SYM (rel->r_info);
9114               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9115                               r_symndx, ibfd))
9116                 goto error_ret;
9117
9118               if (sym_sec == NULL
9119                   || sym_sec->output_section == NULL
9120                   || discarded_section (sym_sec))
9121                 continue;
9122
9123               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9124                 continue;
9125
9126               if (h != NULL)
9127                 {
9128                   if (h->type == STT_GNU_IFUNC)
9129                     continue;
9130                   val = h->root.u.def.value;
9131                 }
9132               else
9133                 {
9134                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9135                     continue;
9136                   val = sym->st_value;
9137                 }
9138               val += rel->r_addend;
9139               val += sym_sec->output_section->vma + sym_sec->output_offset;
9140
9141               /* We don't yet know the exact toc pointer value, but we
9142                  know it will be somewhere in the toc section.  Don't
9143                  optimize if the difference from any possible toc
9144                  pointer is outside [ff..f80008000, 7fff7fff].  */
9145               addr = toc->output_section->vma + TOC_BASE_OFF;
9146               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9147                 continue;
9148
9149               addr = toc->output_section->vma + toc->output_section->rawsize;
9150               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9151                 continue;
9152
9153               if (skip == NULL)
9154                 {
9155                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9156                   if (skip == NULL)
9157                     goto error_ret;
9158                 }
9159
9160               skip[rel->r_offset >> 3]
9161                 |= can_optimize | ((rel - toc_relocs) << 2);
9162             }
9163         }
9164
9165       if (skip == NULL)
9166         continue;
9167
9168       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9169       if (used == NULL)
9170         {
9171         error_ret:
9172           if (local_syms != NULL
9173               && symtab_hdr->contents != (unsigned char *) local_syms)
9174             free (local_syms);
9175           if (sec != NULL
9176               && relstart != NULL
9177               && elf_section_data (sec)->relocs != relstart)
9178             free (relstart);
9179           if (toc_relocs != NULL
9180               && elf_section_data (toc)->relocs != toc_relocs)
9181             free (toc_relocs);
9182           if (skip != NULL)
9183             free (skip);
9184           return FALSE;
9185         }
9186
9187       /* Now check all kept sections that might reference the toc.
9188          Check the toc itself last.  */
9189       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9190                   : ibfd->sections);
9191            sec != NULL;
9192            sec = (sec == toc ? NULL
9193                   : sec->next == NULL ? toc
9194                   : sec->next == toc && toc->next ? toc->next
9195                   : sec->next))
9196         {
9197           int repeat;
9198
9199           if (sec->reloc_count == 0
9200               || discarded_section (sec)
9201               || get_opd_info (sec)
9202               || (sec->flags & SEC_ALLOC) == 0
9203               || (sec->flags & SEC_DEBUGGING) != 0)
9204             continue;
9205
9206           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9207                                                 info->keep_memory);
9208           if (relstart == NULL)
9209             {
9210               free (used);
9211               goto error_ret;
9212             }
9213
9214           /* Mark toc entries referenced as used.  */
9215           do
9216             {
9217               repeat = 0;
9218               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9219                 {
9220                   enum elf_ppc64_reloc_type r_type;
9221                   unsigned long r_symndx;
9222                   asection *sym_sec;
9223                   struct elf_link_hash_entry *h;
9224                   Elf_Internal_Sym *sym;
9225                   bfd_vma val;
9226                   enum {no_check, check_lo, check_ha} insn_check;
9227
9228                   r_type = ELF64_R_TYPE (rel->r_info);
9229                   switch (r_type)
9230                     {
9231                     default:
9232                       insn_check = no_check;
9233                       break;
9234
9235                     case R_PPC64_GOT_TLSLD16_HA:
9236                     case R_PPC64_GOT_TLSGD16_HA:
9237                     case R_PPC64_GOT_TPREL16_HA:
9238                     case R_PPC64_GOT_DTPREL16_HA:
9239                     case R_PPC64_GOT16_HA:
9240                     case R_PPC64_TOC16_HA:
9241                       insn_check = check_ha;
9242                       break;
9243
9244                     case R_PPC64_GOT_TLSLD16_LO:
9245                     case R_PPC64_GOT_TLSGD16_LO:
9246                     case R_PPC64_GOT_TPREL16_LO_DS:
9247                     case R_PPC64_GOT_DTPREL16_LO_DS:
9248                     case R_PPC64_GOT16_LO:
9249                     case R_PPC64_GOT16_LO_DS:
9250                     case R_PPC64_TOC16_LO:
9251                     case R_PPC64_TOC16_LO_DS:
9252                       insn_check = check_lo;
9253                       break;
9254                     }
9255
9256                   if (insn_check != no_check)
9257                     {
9258                       bfd_vma off = rel->r_offset & ~3;
9259                       unsigned char buf[4];
9260                       unsigned int insn;
9261
9262                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9263                         {
9264                           free (used);
9265                           goto error_ret;
9266                         }
9267                       insn = bfd_get_32 (ibfd, buf);
9268                       if (insn_check == check_lo
9269                           ? !ok_lo_toc_insn (insn, r_type)
9270                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9271                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9272                         {
9273                           char str[12];
9274
9275                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9276                           sprintf (str, "%#08x", insn);
9277                           info->callbacks->einfo
9278                             /* xgettext:c-format */
9279                             (_("%H: toc optimization is not supported for"
9280                                " %s instruction.\n"),
9281                              ibfd, sec, rel->r_offset & ~3, str);
9282                         }
9283                     }
9284
9285                   switch (r_type)
9286                     {
9287                     case R_PPC64_TOC16:
9288                     case R_PPC64_TOC16_LO:
9289                     case R_PPC64_TOC16_HI:
9290                     case R_PPC64_TOC16_HA:
9291                     case R_PPC64_TOC16_DS:
9292                     case R_PPC64_TOC16_LO_DS:
9293                       /* In case we're taking addresses of toc entries.  */
9294                     case R_PPC64_ADDR64:
9295                       break;
9296
9297                     default:
9298                       continue;
9299                     }
9300
9301                   r_symndx = ELF64_R_SYM (rel->r_info);
9302                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9303                                   r_symndx, ibfd))
9304                     {
9305                       free (used);
9306                       goto error_ret;
9307                     }
9308
9309                   if (sym_sec != toc)
9310                     continue;
9311
9312                   if (h != NULL)
9313                     val = h->root.u.def.value;
9314                   else
9315                     val = sym->st_value;
9316                   val += rel->r_addend;
9317
9318                   if (val >= toc->size)
9319                     continue;
9320
9321                   if ((skip[val >> 3] & can_optimize) != 0)
9322                     {
9323                       bfd_vma off;
9324                       unsigned char opc;
9325
9326                       switch (r_type)
9327                         {
9328                         case R_PPC64_TOC16_HA:
9329                           break;
9330
9331                         case R_PPC64_TOC16_LO_DS:
9332                           off = rel->r_offset;
9333                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9334                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9335                                                          off, 1))
9336                             {
9337                               free (used);
9338                               goto error_ret;
9339                             }
9340                           if ((opc & (0x3f << 2)) == (58u << 2))
9341                             break;
9342                           /* Fall through.  */
9343
9344                         default:
9345                           /* Wrong sort of reloc, or not a ld.  We may
9346                              as well clear ref_from_discarded too.  */
9347                           skip[val >> 3] = 0;
9348                         }
9349                     }
9350
9351                   if (sec != toc)
9352                     used[val >> 3] = 1;
9353                   /* For the toc section, we only mark as used if this
9354                      entry itself isn't unused.  */
9355                   else if ((used[rel->r_offset >> 3]
9356                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9357                            && !used[val >> 3])
9358                     {
9359                       /* Do all the relocs again, to catch reference
9360                          chains.  */
9361                       repeat = 1;
9362                       used[val >> 3] = 1;
9363                     }
9364                 }
9365             }
9366           while (repeat);
9367
9368           if (elf_section_data (sec)->relocs != relstart)
9369             free (relstart);
9370         }
9371
9372       /* Merge the used and skip arrays.  Assume that TOC
9373          doublewords not appearing as either used or unused belong
9374          to to an entry more than one doubleword in size.  */
9375       for (drop = skip, keep = used, last = 0, some_unused = 0;
9376            drop < skip + (toc->size + 7) / 8;
9377            ++drop, ++keep)
9378         {
9379           if (*keep)
9380             {
9381               *drop &= ~ref_from_discarded;
9382               if ((*drop & can_optimize) != 0)
9383                 some_unused = 1;
9384               last = 0;
9385             }
9386           else if ((*drop & ref_from_discarded) != 0)
9387             {
9388               some_unused = 1;
9389               last = ref_from_discarded;
9390             }
9391           else
9392             *drop = last;
9393         }
9394
9395       free (used);
9396
9397       if (some_unused)
9398         {
9399           bfd_byte *contents, *src;
9400           unsigned long off;
9401           Elf_Internal_Sym *sym;
9402           bfd_boolean local_toc_syms = FALSE;
9403
9404           /* Shuffle the toc contents, and at the same time convert the
9405              skip array from booleans into offsets.  */
9406           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9407             goto error_ret;
9408
9409           elf_section_data (toc)->this_hdr.contents = contents;
9410
9411           for (src = contents, off = 0, drop = skip;
9412                src < contents + toc->size;
9413                src += 8, ++drop)
9414             {
9415               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9416                 off += 8;
9417               else if (off != 0)
9418                 {
9419                   *drop = off;
9420                   memcpy (src - off, src, 8);
9421                 }
9422             }
9423           *drop = off;
9424           toc->rawsize = toc->size;
9425           toc->size = src - contents - off;
9426
9427           /* Adjust addends for relocs against the toc section sym,
9428              and optimize any accesses we can.  */
9429           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9430             {
9431               if (sec->reloc_count == 0
9432                   || discarded_section (sec))
9433                 continue;
9434
9435               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9436                                                     info->keep_memory);
9437               if (relstart == NULL)
9438                 goto error_ret;
9439
9440               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9441                 {
9442                   enum elf_ppc64_reloc_type r_type;
9443                   unsigned long r_symndx;
9444                   asection *sym_sec;
9445                   struct elf_link_hash_entry *h;
9446                   bfd_vma val;
9447
9448                   r_type = ELF64_R_TYPE (rel->r_info);
9449                   switch (r_type)
9450                     {
9451                     default:
9452                       continue;
9453
9454                     case R_PPC64_TOC16:
9455                     case R_PPC64_TOC16_LO:
9456                     case R_PPC64_TOC16_HI:
9457                     case R_PPC64_TOC16_HA:
9458                     case R_PPC64_TOC16_DS:
9459                     case R_PPC64_TOC16_LO_DS:
9460                     case R_PPC64_ADDR64:
9461                       break;
9462                     }
9463
9464                   r_symndx = ELF64_R_SYM (rel->r_info);
9465                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9466                                   r_symndx, ibfd))
9467                     goto error_ret;
9468
9469                   if (sym_sec != toc)
9470                     continue;
9471
9472                   if (h != NULL)
9473                     val = h->root.u.def.value;
9474                   else
9475                     {
9476                       val = sym->st_value;
9477                       if (val != 0)
9478                         local_toc_syms = TRUE;
9479                     }
9480
9481                   val += rel->r_addend;
9482
9483                   if (val > toc->rawsize)
9484                     val = toc->rawsize;
9485                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9486                     continue;
9487                   else if ((skip[val >> 3] & can_optimize) != 0)
9488                     {
9489                       Elf_Internal_Rela *tocrel
9490                         = toc_relocs + (skip[val >> 3] >> 2);
9491                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9492
9493                       switch (r_type)
9494                         {
9495                         case R_PPC64_TOC16_HA:
9496                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9497                           break;
9498
9499                         case R_PPC64_TOC16_LO_DS:
9500                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9501                           break;
9502
9503                         default:
9504                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9505                             ppc_howto_init ();
9506                           info->callbacks->einfo
9507                             /* xgettext:c-format */
9508                             (_("%H: %s references "
9509                                "optimized away TOC entry\n"),
9510                              ibfd, sec, rel->r_offset,
9511                              ppc64_elf_howto_table[r_type]->name);
9512                           bfd_set_error (bfd_error_bad_value);
9513                           goto error_ret;
9514                         }
9515                       rel->r_addend = tocrel->r_addend;
9516                       elf_section_data (sec)->relocs = relstart;
9517                       continue;
9518                     }
9519
9520                   if (h != NULL || sym->st_value != 0)
9521                     continue;
9522
9523                   rel->r_addend -= skip[val >> 3];
9524                   elf_section_data (sec)->relocs = relstart;
9525                 }
9526
9527               if (elf_section_data (sec)->relocs != relstart)
9528                 free (relstart);
9529             }
9530
9531           /* We shouldn't have local or global symbols defined in the TOC,
9532              but handle them anyway.  */
9533           if (local_syms != NULL)
9534             for (sym = local_syms;
9535                  sym < local_syms + symtab_hdr->sh_info;
9536                  ++sym)
9537               if (sym->st_value != 0
9538                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9539                 {
9540                   unsigned long i;
9541
9542                   if (sym->st_value > toc->rawsize)
9543                     i = toc->rawsize >> 3;
9544                   else
9545                     i = sym->st_value >> 3;
9546
9547                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9548                     {
9549                       if (local_toc_syms)
9550                         _bfd_error_handler
9551                           (_("%s defined on removed toc entry"),
9552                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9553                       do
9554                         ++i;
9555                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9556                       sym->st_value = (bfd_vma) i << 3;
9557                     }
9558
9559                   sym->st_value -= skip[i];
9560                   symtab_hdr->contents = (unsigned char *) local_syms;
9561                 }
9562
9563           /* Adjust any global syms defined in this toc input section.  */
9564           if (toc_inf.global_toc_syms)
9565             {
9566               toc_inf.toc = toc;
9567               toc_inf.skip = skip;
9568               toc_inf.global_toc_syms = FALSE;
9569               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9570                                       &toc_inf);
9571             }
9572
9573           if (toc->reloc_count != 0)
9574             {
9575               Elf_Internal_Shdr *rel_hdr;
9576               Elf_Internal_Rela *wrel;
9577               bfd_size_type sz;
9578
9579               /* Remove unused toc relocs, and adjust those we keep.  */
9580               if (toc_relocs == NULL)
9581                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9582                                                         info->keep_memory);
9583               if (toc_relocs == NULL)
9584                 goto error_ret;
9585
9586               wrel = toc_relocs;
9587               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9588                 if ((skip[rel->r_offset >> 3]
9589                      & (ref_from_discarded | can_optimize)) == 0)
9590                   {
9591                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9592                     wrel->r_info = rel->r_info;
9593                     wrel->r_addend = rel->r_addend;
9594                     ++wrel;
9595                   }
9596                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9597                                             &local_syms, NULL, NULL))
9598                   goto error_ret;
9599
9600               elf_section_data (toc)->relocs = toc_relocs;
9601               toc->reloc_count = wrel - toc_relocs;
9602               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9603               sz = rel_hdr->sh_entsize;
9604               rel_hdr->sh_size = toc->reloc_count * sz;
9605             }
9606         }
9607       else if (toc_relocs != NULL
9608                && elf_section_data (toc)->relocs != toc_relocs)
9609         free (toc_relocs);
9610
9611       if (local_syms != NULL
9612           && symtab_hdr->contents != (unsigned char *) local_syms)
9613         {
9614           if (!info->keep_memory)
9615             free (local_syms);
9616           else
9617             symtab_hdr->contents = (unsigned char *) local_syms;
9618         }
9619       free (skip);
9620     }
9621
9622   return TRUE;
9623 }
9624
9625 /* Return true iff input section I references the TOC using
9626    instructions limited to +/-32k offsets.  */
9627
9628 bfd_boolean
9629 ppc64_elf_has_small_toc_reloc (asection *i)
9630 {
9631   return (is_ppc64_elf (i->owner)
9632           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9633 }
9634
9635 /* Allocate space for one GOT entry.  */
9636
9637 static void
9638 allocate_got (struct elf_link_hash_entry *h,
9639               struct bfd_link_info *info,
9640               struct got_entry *gent)
9641 {
9642   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9643   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9644   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9645                  ? 16 : 8);
9646   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9647                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9648   asection *got = ppc64_elf_tdata (gent->owner)->got;
9649
9650   gent->got.offset = got->size;
9651   got->size += entsize;
9652
9653   if (h->type == STT_GNU_IFUNC)
9654     {
9655       htab->elf.irelplt->size += rentsize;
9656       htab->got_reli_size += rentsize;
9657     }
9658   else if ((bfd_link_pic (info)
9659             || (htab->elf.dynamic_sections_created
9660                 && h->dynindx != -1
9661                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9662            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9663                || h->root.type != bfd_link_hash_undefweak))
9664     {
9665       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9666       relgot->size += rentsize;
9667     }
9668 }
9669
9670 /* This function merges got entries in the same toc group.  */
9671
9672 static void
9673 merge_got_entries (struct got_entry **pent)
9674 {
9675   struct got_entry *ent, *ent2;
9676
9677   for (ent = *pent; ent != NULL; ent = ent->next)
9678     if (!ent->is_indirect)
9679       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9680         if (!ent2->is_indirect
9681             && ent2->addend == ent->addend
9682             && ent2->tls_type == ent->tls_type
9683             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9684           {
9685             ent2->is_indirect = TRUE;
9686             ent2->got.ent = ent;
9687           }
9688 }
9689
9690 /* If H is undefined weak, make it dynamic if that makes sense.  */
9691
9692 static bfd_boolean
9693 ensure_undefweak_dynamic (struct bfd_link_info *info,
9694                           struct elf_link_hash_entry *h)
9695 {
9696   struct elf_link_hash_table *htab = elf_hash_table (info);
9697
9698   if (htab->dynamic_sections_created
9699       && info->dynamic_undefined_weak != 0
9700       && h->root.type == bfd_link_hash_undefweak
9701       && h->dynindx == -1
9702       && !h->forced_local
9703       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9704     return bfd_elf_link_record_dynamic_symbol (info, h);
9705   return TRUE;
9706 }
9707
9708 /* Allocate space in .plt, .got and associated reloc sections for
9709    dynamic relocs.  */
9710
9711 static bfd_boolean
9712 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9713 {
9714   struct bfd_link_info *info;
9715   struct ppc_link_hash_table *htab;
9716   asection *s;
9717   struct ppc_link_hash_entry *eh;
9718   struct got_entry **pgent, *gent;
9719
9720   if (h->root.type == bfd_link_hash_indirect)
9721     return TRUE;
9722
9723   info = (struct bfd_link_info *) inf;
9724   htab = ppc_hash_table (info);
9725   if (htab == NULL)
9726     return FALSE;
9727
9728   eh = (struct ppc_link_hash_entry *) h;
9729   /* Run through the TLS GD got entries first if we're changing them
9730      to TPREL.  */
9731   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9732     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9733       if (gent->got.refcount > 0
9734           && (gent->tls_type & TLS_GD) != 0)
9735         {
9736           /* This was a GD entry that has been converted to TPREL.  If
9737              there happens to be a TPREL entry we can use that one.  */
9738           struct got_entry *ent;
9739           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9740             if (ent->got.refcount > 0
9741                 && (ent->tls_type & TLS_TPREL) != 0
9742                 && ent->addend == gent->addend
9743                 && ent->owner == gent->owner)
9744               {
9745                 gent->got.refcount = 0;
9746                 break;
9747               }
9748
9749           /* If not, then we'll be using our own TPREL entry.  */
9750           if (gent->got.refcount != 0)
9751             gent->tls_type = TLS_TLS | TLS_TPREL;
9752         }
9753
9754   /* Remove any list entry that won't generate a word in the GOT before
9755      we call merge_got_entries.  Otherwise we risk merging to empty
9756      entries.  */
9757   pgent = &h->got.glist;
9758   while ((gent = *pgent) != NULL)
9759     if (gent->got.refcount > 0)
9760       {
9761         if ((gent->tls_type & TLS_LD) != 0
9762             && !h->def_dynamic)
9763           {
9764             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9765             *pgent = gent->next;
9766           }
9767         else
9768           pgent = &gent->next;
9769       }
9770     else
9771       *pgent = gent->next;
9772
9773   if (!htab->do_multi_toc)
9774     merge_got_entries (&h->got.glist);
9775
9776   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9777     if (!gent->is_indirect)
9778       {
9779         /* Make sure this symbol is output as a dynamic symbol.
9780            Undefined weak syms won't yet be marked as dynamic.  */
9781         if (!ensure_undefweak_dynamic (info, h))
9782           return FALSE;
9783
9784         if (!is_ppc64_elf (gent->owner))
9785           abort ();
9786
9787         allocate_got (h, info, gent);
9788       }
9789
9790   /* If no dynamic sections we can't have dynamic relocs, except for
9791      IFUNCs which are handled even in static executables.  */
9792   if (!htab->elf.dynamic_sections_created
9793       && h->type != STT_GNU_IFUNC)
9794     eh->dyn_relocs = NULL;
9795
9796   /* Also discard relocs on undefined weak syms with non-default
9797      visibility, or when dynamic_undefined_weak says so.  */
9798   else if (h->root.type == bfd_link_hash_undefweak
9799            && (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
9800                || info->dynamic_undefined_weak == 0))
9801     eh->dyn_relocs = NULL;
9802
9803   if (eh->dyn_relocs != NULL)
9804     {
9805       struct elf_dyn_relocs *p, **pp;
9806
9807       /* In the shared -Bsymbolic case, discard space allocated for
9808          dynamic pc-relative relocs against symbols which turn out to
9809          be defined in regular objects.  For the normal shared case,
9810          discard space for relocs that have become local due to symbol
9811          visibility changes.  */
9812
9813       if (bfd_link_pic (info))
9814         {
9815           /* Relocs that use pc_count are those that appear on a call
9816              insn, or certain REL relocs (see must_be_dyn_reloc) that
9817              can be generated via assembly.  We want calls to
9818              protected symbols to resolve directly to the function
9819              rather than going via the plt.  If people want function
9820              pointer comparisons to work as expected then they should
9821              avoid writing weird assembly.  */
9822           if (SYMBOL_CALLS_LOCAL (info, h))
9823             {
9824               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9825                 {
9826                   p->count -= p->pc_count;
9827                   p->pc_count = 0;
9828                   if (p->count == 0)
9829                     *pp = p->next;
9830                   else
9831                     pp = &p->next;
9832                 }
9833             }
9834
9835           if (eh->dyn_relocs != NULL)
9836             {
9837               /* Make sure this symbol is output as a dynamic symbol.
9838                  Undefined weak syms won't yet be marked as dynamic.  */
9839               if (!ensure_undefweak_dynamic (info, h))
9840                 return FALSE;
9841             }
9842         }
9843       else if (h->type == STT_GNU_IFUNC)
9844         {
9845           /* A plt entry is always created when making direct calls to
9846              an ifunc, even when building a static executable, but
9847              that doesn't cover all cases.  We may have only an ifunc
9848              initialised function pointer for a given ifunc symbol.
9849
9850              For ELFv2, dynamic relocations are not required when
9851              generating a global entry PLT stub.  */
9852           if (abiversion (info->output_bfd) >= 2)
9853             {
9854               if (global_entry_stub (h))
9855                 eh->dyn_relocs = NULL;
9856             }
9857
9858           /* For ELFv1 we have function descriptors.  Descriptors need
9859              to be treated like PLT entries and thus have dynamic
9860              relocations.  One exception is when the function
9861              descriptor is copied into .dynbss (which should only
9862              happen with ancient versions of gcc).  */
9863           else if (h->needs_copy)
9864             eh->dyn_relocs = NULL;
9865         }
9866       else if (ELIMINATE_COPY_RELOCS)
9867         {
9868           /* For the non-pic case, discard space for relocs against
9869              symbols which turn out to need copy relocs or are not
9870              dynamic.  */
9871           if (!h->non_got_ref
9872               && !h->def_regular)
9873             {
9874               /* Make sure this symbol is output as a dynamic symbol.
9875                  Undefined weak syms won't yet be marked as dynamic.  */
9876               if (!ensure_undefweak_dynamic (info, h))
9877                 return FALSE;
9878
9879               if (h->dynindx == -1)
9880                 eh->dyn_relocs = NULL;
9881             }
9882           else
9883             eh->dyn_relocs = NULL;
9884         }
9885
9886       /* Finally, allocate space.  */
9887       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9888         {
9889           asection *sreloc = elf_section_data (p->sec)->sreloc;
9890           if (eh->elf.type == STT_GNU_IFUNC)
9891             sreloc = htab->elf.irelplt;
9892           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9893         }
9894     }
9895
9896   if ((htab->elf.dynamic_sections_created
9897        && h->dynindx != -1)
9898       || h->type == STT_GNU_IFUNC)
9899     {
9900       struct plt_entry *pent;
9901       bfd_boolean doneone = FALSE;
9902       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9903         if (pent->plt.refcount > 0)
9904           {
9905             if (!htab->elf.dynamic_sections_created
9906                 || h->dynindx == -1)
9907               {
9908                 s = htab->elf.iplt;
9909                 pent->plt.offset = s->size;
9910                 s->size += PLT_ENTRY_SIZE (htab);
9911                 s = htab->elf.irelplt;
9912               }
9913             else
9914               {
9915                 /* If this is the first .plt entry, make room for the special
9916                    first entry.  */
9917                 s = htab->elf.splt;
9918                 if (s->size == 0)
9919                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9920
9921                 pent->plt.offset = s->size;
9922
9923                 /* Make room for this entry.  */
9924                 s->size += PLT_ENTRY_SIZE (htab);
9925
9926                 /* Make room for the .glink code.  */
9927                 s = htab->glink;
9928                 if (s->size == 0)
9929                   s->size += GLINK_CALL_STUB_SIZE;
9930                 if (htab->opd_abi)
9931                   {
9932                     /* We need bigger stubs past index 32767.  */
9933                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9934                       s->size += 4;
9935                     s->size += 2*4;
9936                   }
9937                 else
9938                   s->size += 4;
9939
9940                 /* We also need to make an entry in the .rela.plt section.  */
9941                 s = htab->elf.srelplt;
9942               }
9943             s->size += sizeof (Elf64_External_Rela);
9944             doneone = TRUE;
9945           }
9946         else
9947           pent->plt.offset = (bfd_vma) -1;
9948       if (!doneone)
9949         {
9950           h->plt.plist = NULL;
9951           h->needs_plt = 0;
9952         }
9953     }
9954   else
9955     {
9956       h->plt.plist = NULL;
9957       h->needs_plt = 0;
9958     }
9959
9960   return TRUE;
9961 }
9962
9963 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9964    to set up space for global entry stubs.  These are put in glink,
9965    after the branch table.  */
9966
9967 static bfd_boolean
9968 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9969 {
9970   struct bfd_link_info *info;
9971   struct ppc_link_hash_table *htab;
9972   struct plt_entry *pent;
9973   asection *s;
9974
9975   if (h->root.type == bfd_link_hash_indirect)
9976     return TRUE;
9977
9978   if (!h->pointer_equality_needed)
9979     return TRUE;
9980
9981   if (h->def_regular)
9982     return TRUE;
9983
9984   info = inf;
9985   htab = ppc_hash_table (info);
9986   if (htab == NULL)
9987     return FALSE;
9988
9989   s = htab->glink;
9990   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9991     if (pent->plt.offset != (bfd_vma) -1
9992         && pent->addend == 0)
9993       {
9994         /* For ELFv2, if this symbol is not defined in a regular file
9995            and we are not generating a shared library or pie, then we
9996            need to define the symbol in the executable on a call stub.
9997            This is to avoid text relocations.  */
9998         s->size = (s->size + 15) & -16;
9999         h->root.type = bfd_link_hash_defined;
10000         h->root.u.def.section = s;
10001         h->root.u.def.value = s->size;
10002         s->size += 16;
10003         break;
10004       }
10005   return TRUE;
10006 }
10007
10008 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10009    read-only sections.  */
10010
10011 static bfd_boolean
10012 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10013 {
10014   if (h->root.type == bfd_link_hash_indirect)
10015     return TRUE;
10016
10017   if (readonly_dynrelocs (h))
10018     {
10019       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10020
10021       /* Not an error, just cut short the traversal.  */
10022       return FALSE;
10023     }
10024   return TRUE;
10025 }
10026
10027 /* Set the sizes of the dynamic sections.  */
10028
10029 static bfd_boolean
10030 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10031                                  struct bfd_link_info *info)
10032 {
10033   struct ppc_link_hash_table *htab;
10034   bfd *dynobj;
10035   asection *s;
10036   bfd_boolean relocs;
10037   bfd *ibfd;
10038   struct got_entry *first_tlsld;
10039
10040   htab = ppc_hash_table (info);
10041   if (htab == NULL)
10042     return FALSE;
10043
10044   dynobj = htab->elf.dynobj;
10045   if (dynobj == NULL)
10046     abort ();
10047
10048   if (htab->elf.dynamic_sections_created)
10049     {
10050       /* Set the contents of the .interp section to the interpreter.  */
10051       if (bfd_link_executable (info) && !info->nointerp)
10052         {
10053           s = bfd_get_linker_section (dynobj, ".interp");
10054           if (s == NULL)
10055             abort ();
10056           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10057           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10058         }
10059     }
10060
10061   /* Set up .got offsets for local syms, and space for local dynamic
10062      relocs.  */
10063   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10064     {
10065       struct got_entry **lgot_ents;
10066       struct got_entry **end_lgot_ents;
10067       struct plt_entry **local_plt;
10068       struct plt_entry **end_local_plt;
10069       unsigned char *lgot_masks;
10070       bfd_size_type locsymcount;
10071       Elf_Internal_Shdr *symtab_hdr;
10072
10073       if (!is_ppc64_elf (ibfd))
10074         continue;
10075
10076       for (s = ibfd->sections; s != NULL; s = s->next)
10077         {
10078           struct ppc_dyn_relocs *p;
10079
10080           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10081             {
10082               if (!bfd_is_abs_section (p->sec)
10083                   && bfd_is_abs_section (p->sec->output_section))
10084                 {
10085                   /* Input section has been discarded, either because
10086                      it is a copy of a linkonce section or due to
10087                      linker script /DISCARD/, so we'll be discarding
10088                      the relocs too.  */
10089                 }
10090               else if (p->count != 0)
10091                 {
10092                   asection *srel = elf_section_data (p->sec)->sreloc;
10093                   if (p->ifunc)
10094                     srel = htab->elf.irelplt;
10095                   srel->size += p->count * sizeof (Elf64_External_Rela);
10096                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10097                     info->flags |= DF_TEXTREL;
10098                 }
10099             }
10100         }
10101
10102       lgot_ents = elf_local_got_ents (ibfd);
10103       if (!lgot_ents)
10104         continue;
10105
10106       symtab_hdr = &elf_symtab_hdr (ibfd);
10107       locsymcount = symtab_hdr->sh_info;
10108       end_lgot_ents = lgot_ents + locsymcount;
10109       local_plt = (struct plt_entry **) end_lgot_ents;
10110       end_local_plt = local_plt + locsymcount;
10111       lgot_masks = (unsigned char *) end_local_plt;
10112       s = ppc64_elf_tdata (ibfd)->got;
10113       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10114         {
10115           struct got_entry **pent, *ent;
10116
10117           pent = lgot_ents;
10118           while ((ent = *pent) != NULL)
10119             if (ent->got.refcount > 0)
10120               {
10121                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10122                   {
10123                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10124                     *pent = ent->next;
10125                   }
10126                 else
10127                   {
10128                     unsigned int ent_size = 8;
10129                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10130
10131                     ent->got.offset = s->size;
10132                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10133                       {
10134                         ent_size *= 2;
10135                         rel_size *= 2;
10136                       }
10137                     s->size += ent_size;
10138                     if ((*lgot_masks & PLT_IFUNC) != 0)
10139                       {
10140                         htab->elf.irelplt->size += rel_size;
10141                         htab->got_reli_size += rel_size;
10142                       }
10143                     else if (bfd_link_pic (info))
10144                       {
10145                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10146                         srel->size += rel_size;
10147                       }
10148                     pent = &ent->next;
10149                   }
10150               }
10151             else
10152               *pent = ent->next;
10153         }
10154
10155       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10156       for (; local_plt < end_local_plt; ++local_plt)
10157         {
10158           struct plt_entry *ent;
10159
10160           for (ent = *local_plt; ent != NULL; ent = ent->next)
10161             if (ent->plt.refcount > 0)
10162               {
10163                 s = htab->elf.iplt;
10164                 ent->plt.offset = s->size;
10165                 s->size += PLT_ENTRY_SIZE (htab);
10166
10167                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10168               }
10169             else
10170               ent->plt.offset = (bfd_vma) -1;
10171         }
10172     }
10173
10174   /* Allocate global sym .plt and .got entries, and space for global
10175      sym dynamic relocs.  */
10176   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10177   /* Stash the end of glink branch table.  */
10178   if (htab->glink != NULL)
10179     htab->glink->rawsize = htab->glink->size;
10180
10181   if (!htab->opd_abi && !bfd_link_pic (info))
10182     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10183
10184   first_tlsld = NULL;
10185   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10186     {
10187       struct got_entry *ent;
10188
10189       if (!is_ppc64_elf (ibfd))
10190         continue;
10191
10192       ent = ppc64_tlsld_got (ibfd);
10193       if (ent->got.refcount > 0)
10194         {
10195           if (!htab->do_multi_toc && first_tlsld != NULL)
10196             {
10197               ent->is_indirect = TRUE;
10198               ent->got.ent = first_tlsld;
10199             }
10200           else
10201             {
10202               if (first_tlsld == NULL)
10203                 first_tlsld = ent;
10204               s = ppc64_elf_tdata (ibfd)->got;
10205               ent->got.offset = s->size;
10206               ent->owner = ibfd;
10207               s->size += 16;
10208               if (bfd_link_pic (info))
10209                 {
10210                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10211                   srel->size += sizeof (Elf64_External_Rela);
10212                 }
10213             }
10214         }
10215       else
10216         ent->got.offset = (bfd_vma) -1;
10217     }
10218
10219   /* We now have determined the sizes of the various dynamic sections.
10220      Allocate memory for them.  */
10221   relocs = FALSE;
10222   for (s = dynobj->sections; s != NULL; s = s->next)
10223     {
10224       if ((s->flags & SEC_LINKER_CREATED) == 0)
10225         continue;
10226
10227       if (s == htab->brlt || s == htab->relbrlt)
10228         /* These haven't been allocated yet;  don't strip.  */
10229         continue;
10230       else if (s == htab->elf.sgot
10231                || s == htab->elf.splt
10232                || s == htab->elf.iplt
10233                || s == htab->glink
10234                || s == htab->elf.sdynbss
10235                || s == htab->elf.sdynrelro)
10236         {
10237           /* Strip this section if we don't need it; see the
10238              comment below.  */
10239         }
10240       else if (s == htab->glink_eh_frame)
10241         {
10242           if (!bfd_is_abs_section (s->output_section))
10243             /* Not sized yet.  */
10244             continue;
10245         }
10246       else if (CONST_STRNEQ (s->name, ".rela"))
10247         {
10248           if (s->size != 0)
10249             {
10250               if (s != htab->elf.srelplt)
10251                 relocs = TRUE;
10252
10253               /* We use the reloc_count field as a counter if we need
10254                  to copy relocs into the output file.  */
10255               s->reloc_count = 0;
10256             }
10257         }
10258       else
10259         {
10260           /* It's not one of our sections, so don't allocate space.  */
10261           continue;
10262         }
10263
10264       if (s->size == 0)
10265         {
10266           /* If we don't need this section, strip it from the
10267              output file.  This is mostly to handle .rela.bss and
10268              .rela.plt.  We must create both sections in
10269              create_dynamic_sections, because they must be created
10270              before the linker maps input sections to output
10271              sections.  The linker does that before
10272              adjust_dynamic_symbol is called, and it is that
10273              function which decides whether anything needs to go
10274              into these sections.  */
10275           s->flags |= SEC_EXCLUDE;
10276           continue;
10277         }
10278
10279       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10280         continue;
10281
10282       /* Allocate memory for the section contents.  We use bfd_zalloc
10283          here in case unused entries are not reclaimed before the
10284          section's contents are written out.  This should not happen,
10285          but this way if it does we get a R_PPC64_NONE reloc in .rela
10286          sections instead of garbage.
10287          We also rely on the section contents being zero when writing
10288          the GOT and .dynrelro.  */
10289       s->contents = bfd_zalloc (dynobj, s->size);
10290       if (s->contents == NULL)
10291         return FALSE;
10292     }
10293
10294   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10295     {
10296       if (!is_ppc64_elf (ibfd))
10297         continue;
10298
10299       s = ppc64_elf_tdata (ibfd)->got;
10300       if (s != NULL && s != htab->elf.sgot)
10301         {
10302           if (s->size == 0)
10303             s->flags |= SEC_EXCLUDE;
10304           else
10305             {
10306               s->contents = bfd_zalloc (ibfd, s->size);
10307               if (s->contents == NULL)
10308                 return FALSE;
10309             }
10310         }
10311       s = ppc64_elf_tdata (ibfd)->relgot;
10312       if (s != NULL)
10313         {
10314           if (s->size == 0)
10315             s->flags |= SEC_EXCLUDE;
10316           else
10317             {
10318               s->contents = bfd_zalloc (ibfd, s->size);
10319               if (s->contents == NULL)
10320                 return FALSE;
10321               relocs = TRUE;
10322               s->reloc_count = 0;
10323             }
10324         }
10325     }
10326
10327   if (htab->elf.dynamic_sections_created)
10328     {
10329       bfd_boolean tls_opt;
10330
10331       /* Add some entries to the .dynamic section.  We fill in the
10332          values later, in ppc64_elf_finish_dynamic_sections, but we
10333          must add the entries now so that we get the correct size for
10334          the .dynamic section.  The DT_DEBUG entry is filled in by the
10335          dynamic linker and used by the debugger.  */
10336 #define add_dynamic_entry(TAG, VAL) \
10337   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10338
10339       if (bfd_link_executable (info))
10340         {
10341           if (!add_dynamic_entry (DT_DEBUG, 0))
10342             return FALSE;
10343         }
10344
10345       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10346         {
10347           if (!add_dynamic_entry (DT_PLTGOT, 0)
10348               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10349               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10350               || !add_dynamic_entry (DT_JMPREL, 0)
10351               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10352             return FALSE;
10353         }
10354
10355       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10356         {
10357           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10358               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10359             return FALSE;
10360         }
10361
10362       tls_opt = (htab->params->tls_get_addr_opt
10363                  && htab->tls_get_addr_fd != NULL
10364                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10365       if (tls_opt || !htab->opd_abi)
10366         {
10367           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10368             return FALSE;
10369         }
10370
10371       if (relocs)
10372         {
10373           if (!add_dynamic_entry (DT_RELA, 0)
10374               || !add_dynamic_entry (DT_RELASZ, 0)
10375               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10376             return FALSE;
10377
10378           /* If any dynamic relocs apply to a read-only section,
10379              then we need a DT_TEXTREL entry.  */
10380           if ((info->flags & DF_TEXTREL) == 0)
10381             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10382
10383           if ((info->flags & DF_TEXTREL) != 0)
10384             {
10385               if (!add_dynamic_entry (DT_TEXTREL, 0))
10386                 return FALSE;
10387             }
10388         }
10389     }
10390 #undef add_dynamic_entry
10391
10392   return TRUE;
10393 }
10394
10395 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10396
10397 static bfd_boolean
10398 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10399 {
10400   if (h->plt.plist != NULL
10401       && !h->def_regular
10402       && !h->pointer_equality_needed)
10403     return FALSE;
10404
10405   return _bfd_elf_hash_symbol (h);
10406 }
10407
10408 /* Determine the type of stub needed, if any, for a call.  */
10409
10410 static inline enum ppc_stub_type
10411 ppc_type_of_stub (asection *input_sec,
10412                   const Elf_Internal_Rela *rel,
10413                   struct ppc_link_hash_entry **hash,
10414                   struct plt_entry **plt_ent,
10415                   bfd_vma destination,
10416                   unsigned long local_off)
10417 {
10418   struct ppc_link_hash_entry *h = *hash;
10419   bfd_vma location;
10420   bfd_vma branch_offset;
10421   bfd_vma max_branch_offset;
10422   enum elf_ppc64_reloc_type r_type;
10423
10424   if (h != NULL)
10425     {
10426       struct plt_entry *ent;
10427       struct ppc_link_hash_entry *fdh = h;
10428       if (h->oh != NULL
10429           && h->oh->is_func_descriptor)
10430         {
10431           fdh = ppc_follow_link (h->oh);
10432           *hash = fdh;
10433         }
10434
10435       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10436         if (ent->addend == rel->r_addend
10437             && ent->plt.offset != (bfd_vma) -1)
10438           {
10439             *plt_ent = ent;
10440             return ppc_stub_plt_call;
10441           }
10442
10443       /* Here, we know we don't have a plt entry.  If we don't have a
10444          either a defined function descriptor or a defined entry symbol
10445          in a regular object file, then it is pointless trying to make
10446          any other type of stub.  */
10447       if (!is_static_defined (&fdh->elf)
10448           && !is_static_defined (&h->elf))
10449         return ppc_stub_none;
10450     }
10451   else if (elf_local_got_ents (input_sec->owner) != NULL)
10452     {
10453       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10454       struct plt_entry **local_plt = (struct plt_entry **)
10455         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10456       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10457
10458       if (local_plt[r_symndx] != NULL)
10459         {
10460           struct plt_entry *ent;
10461
10462           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10463             if (ent->addend == rel->r_addend
10464                 && ent->plt.offset != (bfd_vma) -1)
10465               {
10466                 *plt_ent = ent;
10467                 return ppc_stub_plt_call;
10468               }
10469         }
10470     }
10471
10472   /* Determine where the call point is.  */
10473   location = (input_sec->output_offset
10474               + input_sec->output_section->vma
10475               + rel->r_offset);
10476
10477   branch_offset = destination - location;
10478   r_type = ELF64_R_TYPE (rel->r_info);
10479
10480   /* Determine if a long branch stub is needed.  */
10481   max_branch_offset = 1 << 25;
10482   if (r_type != R_PPC64_REL24)
10483     max_branch_offset = 1 << 15;
10484
10485   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10486     /* We need a stub.  Figure out whether a long_branch or plt_branch
10487        is needed later.  */
10488     return ppc_stub_long_branch;
10489
10490   return ppc_stub_none;
10491 }
10492
10493 /* With power7 weakly ordered memory model, it is possible for ld.so
10494    to update a plt entry in one thread and have another thread see a
10495    stale zero toc entry.  To avoid this we need some sort of acquire
10496    barrier in the call stub.  One solution is to make the load of the
10497    toc word seem to appear to depend on the load of the function entry
10498    word.  Another solution is to test for r2 being zero, and branch to
10499    the appropriate glink entry if so.
10500
10501    .    fake dep barrier        compare
10502    .    ld 12,xxx(2)            ld 12,xxx(2)
10503    .    mtctr 12                mtctr 12
10504    .    xor 11,12,12            ld 2,xxx+8(2)
10505    .    add 2,2,11              cmpldi 2,0
10506    .    ld 2,xxx+8(2)           bnectr+
10507    .    bctr                    b <glink_entry>
10508
10509    The solution involving the compare turns out to be faster, so
10510    that's what we use unless the branch won't reach.  */
10511
10512 #define ALWAYS_USE_FAKE_DEP 0
10513 #define ALWAYS_EMIT_R2SAVE 0
10514
10515 #define PPC_LO(v) ((v) & 0xffff)
10516 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10517 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10518
10519 static inline unsigned int
10520 plt_stub_size (struct ppc_link_hash_table *htab,
10521                struct ppc_stub_hash_entry *stub_entry,
10522                bfd_vma off)
10523 {
10524   unsigned size = 12;
10525
10526   if (ALWAYS_EMIT_R2SAVE
10527       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10528     size += 4;
10529   if (PPC_HA (off) != 0)
10530     size += 4;
10531   if (htab->opd_abi)
10532     {
10533       size += 4;
10534       if (htab->params->plt_static_chain)
10535         size += 4;
10536       if (htab->params->plt_thread_safe
10537           && htab->elf.dynamic_sections_created
10538           && stub_entry->h != NULL
10539           && stub_entry->h->elf.dynindx != -1)
10540         size += 8;
10541       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10542         size += 4;
10543     }
10544   if (stub_entry->h != NULL
10545       && (stub_entry->h == htab->tls_get_addr_fd
10546           || stub_entry->h == htab->tls_get_addr)
10547       && htab->params->tls_get_addr_opt)
10548     size += 13 * 4;
10549   return size;
10550 }
10551
10552 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10553    then return the padding needed to do so.  */
10554 static inline unsigned int
10555 plt_stub_pad (struct ppc_link_hash_table *htab,
10556               struct ppc_stub_hash_entry *stub_entry,
10557               bfd_vma plt_off)
10558 {
10559   int stub_align = 1 << htab->params->plt_stub_align;
10560   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10561   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10562
10563   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10564       > ((stub_size - 1) & -stub_align))
10565     return stub_align - (stub_off & (stub_align - 1));
10566   return 0;
10567 }
10568
10569 /* Build a .plt call stub.  */
10570
10571 static inline bfd_byte *
10572 build_plt_stub (struct ppc_link_hash_table *htab,
10573                 struct ppc_stub_hash_entry *stub_entry,
10574                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10575 {
10576   bfd *obfd = htab->params->stub_bfd;
10577   bfd_boolean plt_load_toc = htab->opd_abi;
10578   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10579   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10580                                  && htab->elf.dynamic_sections_created
10581                                  && stub_entry->h != NULL
10582                                  && stub_entry->h->elf.dynindx != -1);
10583   bfd_boolean use_fake_dep = plt_thread_safe;
10584   bfd_vma cmp_branch_off = 0;
10585
10586   if (!ALWAYS_USE_FAKE_DEP
10587       && plt_load_toc
10588       && plt_thread_safe
10589       && !((stub_entry->h == htab->tls_get_addr_fd
10590             || stub_entry->h == htab->tls_get_addr)
10591            && htab->params->tls_get_addr_opt))
10592     {
10593       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10594       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10595                           / PLT_ENTRY_SIZE (htab));
10596       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10597       bfd_vma to, from;
10598
10599       if (pltindex > 32768)
10600         glinkoff += (pltindex - 32768) * 4;
10601       to = (glinkoff
10602             + htab->glink->output_offset
10603             + htab->glink->output_section->vma);
10604       from = (p - stub_entry->group->stub_sec->contents
10605               + 4 * (ALWAYS_EMIT_R2SAVE
10606                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10607               + 4 * (PPC_HA (offset) != 0)
10608               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10609                      != PPC_HA (offset))
10610               + 4 * (plt_static_chain != 0)
10611               + 20
10612               + stub_entry->group->stub_sec->output_offset
10613               + stub_entry->group->stub_sec->output_section->vma);
10614       cmp_branch_off = to - from;
10615       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10616     }
10617
10618   if (PPC_HA (offset) != 0)
10619     {
10620       if (r != NULL)
10621         {
10622           if (ALWAYS_EMIT_R2SAVE
10623               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10624             r[0].r_offset += 4;
10625           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10626           r[1].r_offset = r[0].r_offset + 4;
10627           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10628           r[1].r_addend = r[0].r_addend;
10629           if (plt_load_toc)
10630             {
10631               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10632                 {
10633                   r[2].r_offset = r[1].r_offset + 4;
10634                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10635                   r[2].r_addend = r[0].r_addend;
10636                 }
10637               else
10638                 {
10639                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10640                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10641                   r[2].r_addend = r[0].r_addend + 8;
10642                   if (plt_static_chain)
10643                     {
10644                       r[3].r_offset = r[2].r_offset + 4;
10645                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10646                       r[3].r_addend = r[0].r_addend + 16;
10647                     }
10648                 }
10649             }
10650         }
10651       if (ALWAYS_EMIT_R2SAVE
10652           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10653         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10654       if (plt_load_toc)
10655         {
10656           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10657           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10658         }
10659       else
10660         {
10661           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10662           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10663         }
10664       if (plt_load_toc
10665           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10666         {
10667           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10668           offset = 0;
10669         }
10670       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10671       if (plt_load_toc)
10672         {
10673           if (use_fake_dep)
10674             {
10675               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10676               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10677             }
10678           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10679           if (plt_static_chain)
10680             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10681         }
10682     }
10683   else
10684     {
10685       if (r != NULL)
10686         {
10687           if (ALWAYS_EMIT_R2SAVE
10688               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10689             r[0].r_offset += 4;
10690           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10691           if (plt_load_toc)
10692             {
10693               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10694                 {
10695                   r[1].r_offset = r[0].r_offset + 4;
10696                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10697                   r[1].r_addend = r[0].r_addend;
10698                 }
10699               else
10700                 {
10701                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10702                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10703                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10704                   if (plt_static_chain)
10705                     {
10706                       r[2].r_offset = r[1].r_offset + 4;
10707                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10708                       r[2].r_addend = r[0].r_addend + 8;
10709                     }
10710                 }
10711             }
10712         }
10713       if (ALWAYS_EMIT_R2SAVE
10714           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10715         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10716       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10717       if (plt_load_toc
10718           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10719         {
10720           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10721           offset = 0;
10722         }
10723       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10724       if (plt_load_toc)
10725         {
10726           if (use_fake_dep)
10727             {
10728               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10729               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10730             }
10731           if (plt_static_chain)
10732             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10733           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10734         }
10735     }
10736   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10737     {
10738       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10739       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10740       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10741     }
10742   else
10743     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10744   return p;
10745 }
10746
10747 /* Build a special .plt call stub for __tls_get_addr.  */
10748
10749 #define LD_R11_0R3      0xe9630000
10750 #define LD_R12_0R3      0xe9830000
10751 #define MR_R0_R3        0x7c601b78
10752 #define CMPDI_R11_0     0x2c2b0000
10753 #define ADD_R3_R12_R13  0x7c6c6a14
10754 #define BEQLR           0x4d820020
10755 #define MR_R3_R0        0x7c030378
10756 #define STD_R11_0R1     0xf9610000
10757 #define BCTRL           0x4e800421
10758 #define LD_R11_0R1      0xe9610000
10759 #define MTLR_R11        0x7d6803a6
10760
10761 static inline bfd_byte *
10762 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10763                          struct ppc_stub_hash_entry *stub_entry,
10764                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10765 {
10766   bfd *obfd = htab->params->stub_bfd;
10767
10768   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10769   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10770   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10771   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10772   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10773   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10774   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10775   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10776   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10777
10778   if (r != NULL)
10779     r[0].r_offset += 9 * 4;
10780   p = build_plt_stub (htab, stub_entry, p, offset, r);
10781   bfd_put_32 (obfd, BCTRL, p - 4);
10782
10783   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10784   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10785   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10786   bfd_put_32 (obfd, BLR, p),                    p += 4;
10787
10788   return p;
10789 }
10790
10791 static Elf_Internal_Rela *
10792 get_relocs (asection *sec, int count)
10793 {
10794   Elf_Internal_Rela *relocs;
10795   struct bfd_elf_section_data *elfsec_data;
10796
10797   elfsec_data = elf_section_data (sec);
10798   relocs = elfsec_data->relocs;
10799   if (relocs == NULL)
10800     {
10801       bfd_size_type relsize;
10802       relsize = sec->reloc_count * sizeof (*relocs);
10803       relocs = bfd_alloc (sec->owner, relsize);
10804       if (relocs == NULL)
10805         return NULL;
10806       elfsec_data->relocs = relocs;
10807       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10808                                           sizeof (Elf_Internal_Shdr));
10809       if (elfsec_data->rela.hdr == NULL)
10810         return NULL;
10811       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10812                                         * sizeof (Elf64_External_Rela));
10813       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10814       sec->reloc_count = 0;
10815     }
10816   relocs += sec->reloc_count;
10817   sec->reloc_count += count;
10818   return relocs;
10819 }
10820
10821 static bfd_vma
10822 get_r2off (struct bfd_link_info *info,
10823            struct ppc_stub_hash_entry *stub_entry)
10824 {
10825   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10826   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10827
10828   if (r2off == 0)
10829     {
10830       /* Support linking -R objects.  Get the toc pointer from the
10831          opd entry.  */
10832       char buf[8];
10833       if (!htab->opd_abi)
10834         return r2off;
10835       asection *opd = stub_entry->h->elf.root.u.def.section;
10836       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10837
10838       if (strcmp (opd->name, ".opd") != 0
10839           || opd->reloc_count != 0)
10840         {
10841           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10842                                   stub_entry->h->elf.root.root.string);
10843           bfd_set_error (bfd_error_bad_value);
10844           return (bfd_vma) -1;
10845         }
10846       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10847         return (bfd_vma) -1;
10848       r2off = bfd_get_64 (opd->owner, buf);
10849       r2off -= elf_gp (info->output_bfd);
10850     }
10851   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10852   return r2off;
10853 }
10854
10855 static bfd_boolean
10856 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10857 {
10858   struct ppc_stub_hash_entry *stub_entry;
10859   struct ppc_branch_hash_entry *br_entry;
10860   struct bfd_link_info *info;
10861   struct ppc_link_hash_table *htab;
10862   bfd_byte *loc;
10863   bfd_byte *p;
10864   bfd_vma dest, off;
10865   int size;
10866   Elf_Internal_Rela *r;
10867   asection *plt;
10868
10869   /* Massage our args to the form they really have.  */
10870   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10871   info = in_arg;
10872
10873   htab = ppc_hash_table (info);
10874   if (htab == NULL)
10875     return FALSE;
10876
10877   /* Make a note of the offset within the stubs for this entry.  */
10878   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10879   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10880
10881   htab->stub_count[stub_entry->stub_type - 1] += 1;
10882   switch (stub_entry->stub_type)
10883     {
10884     case ppc_stub_long_branch:
10885     case ppc_stub_long_branch_r2off:
10886       /* Branches are relative.  This is where we are going to.  */
10887       dest = (stub_entry->target_value
10888               + stub_entry->target_section->output_offset
10889               + stub_entry->target_section->output_section->vma);
10890       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10891       off = dest;
10892
10893       /* And this is where we are coming from.  */
10894       off -= (stub_entry->stub_offset
10895               + stub_entry->group->stub_sec->output_offset
10896               + stub_entry->group->stub_sec->output_section->vma);
10897
10898       size = 4;
10899       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10900         {
10901           bfd_vma r2off = get_r2off (info, stub_entry);
10902
10903           if (r2off == (bfd_vma) -1)
10904             {
10905               htab->stub_error = TRUE;
10906               return FALSE;
10907             }
10908           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10909           loc += 4;
10910           size = 8;
10911           if (PPC_HA (r2off) != 0)
10912             {
10913               bfd_put_32 (htab->params->stub_bfd,
10914                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10915               loc += 4;
10916               size += 4;
10917             }
10918           if (PPC_LO (r2off) != 0)
10919             {
10920               bfd_put_32 (htab->params->stub_bfd,
10921                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10922               loc += 4;
10923               size += 4;
10924             }
10925           off -= size - 4;
10926         }
10927       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10928
10929       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10930         {
10931           info->callbacks->einfo
10932             (_("%P: long branch stub `%s' offset overflow\n"),
10933              stub_entry->root.string);
10934           htab->stub_error = TRUE;
10935           return FALSE;
10936         }
10937
10938       if (info->emitrelocations)
10939         {
10940           r = get_relocs (stub_entry->group->stub_sec, 1);
10941           if (r == NULL)
10942             return FALSE;
10943           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10944           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10945           r->r_addend = dest;
10946           if (stub_entry->h != NULL)
10947             {
10948               struct elf_link_hash_entry **hashes;
10949               unsigned long symndx;
10950               struct ppc_link_hash_entry *h;
10951
10952               hashes = elf_sym_hashes (htab->params->stub_bfd);
10953               if (hashes == NULL)
10954                 {
10955                   bfd_size_type hsize;
10956
10957                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10958                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10959                   if (hashes == NULL)
10960                     return FALSE;
10961                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10962                   htab->stub_globals = 1;
10963                 }
10964               symndx = htab->stub_globals++;
10965               h = stub_entry->h;
10966               hashes[symndx] = &h->elf;
10967               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10968               if (h->oh != NULL && h->oh->is_func)
10969                 h = ppc_follow_link (h->oh);
10970               if (h->elf.root.u.def.section != stub_entry->target_section)
10971                 /* H is an opd symbol.  The addend must be zero.  */
10972                 r->r_addend = 0;
10973               else
10974                 {
10975                   off = (h->elf.root.u.def.value
10976                          + h->elf.root.u.def.section->output_offset
10977                          + h->elf.root.u.def.section->output_section->vma);
10978                   r->r_addend -= off;
10979                 }
10980             }
10981         }
10982       break;
10983
10984     case ppc_stub_plt_branch:
10985     case ppc_stub_plt_branch_r2off:
10986       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10987                                          stub_entry->root.string + 9,
10988                                          FALSE, FALSE);
10989       if (br_entry == NULL)
10990         {
10991           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10992                                   stub_entry->root.string);
10993           htab->stub_error = TRUE;
10994           return FALSE;
10995         }
10996
10997       dest = (stub_entry->target_value
10998               + stub_entry->target_section->output_offset
10999               + stub_entry->target_section->output_section->vma);
11000       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11001         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11002
11003       bfd_put_64 (htab->brlt->owner, dest,
11004                   htab->brlt->contents + br_entry->offset);
11005
11006       if (br_entry->iter == htab->stub_iteration)
11007         {
11008           br_entry->iter = 0;
11009
11010           if (htab->relbrlt != NULL)
11011             {
11012               /* Create a reloc for the branch lookup table entry.  */
11013               Elf_Internal_Rela rela;
11014               bfd_byte *rl;
11015
11016               rela.r_offset = (br_entry->offset
11017                                + htab->brlt->output_offset
11018                                + htab->brlt->output_section->vma);
11019               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11020               rela.r_addend = dest;
11021
11022               rl = htab->relbrlt->contents;
11023               rl += (htab->relbrlt->reloc_count++
11024                      * sizeof (Elf64_External_Rela));
11025               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11026             }
11027           else if (info->emitrelocations)
11028             {
11029               r = get_relocs (htab->brlt, 1);
11030               if (r == NULL)
11031                 return FALSE;
11032               /* brlt, being SEC_LINKER_CREATED does not go through the
11033                  normal reloc processing.  Symbols and offsets are not
11034                  translated from input file to output file form, so
11035                  set up the offset per the output file.  */
11036               r->r_offset = (br_entry->offset
11037                              + htab->brlt->output_offset
11038                              + htab->brlt->output_section->vma);
11039               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11040               r->r_addend = dest;
11041             }
11042         }
11043
11044       dest = (br_entry->offset
11045               + htab->brlt->output_offset
11046               + htab->brlt->output_section->vma);
11047
11048       off = (dest
11049              - elf_gp (htab->brlt->output_section->owner)
11050              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11051
11052       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11053         {
11054           info->callbacks->einfo
11055             (_("%P: linkage table error against `%T'\n"),
11056              stub_entry->root.string);
11057           bfd_set_error (bfd_error_bad_value);
11058           htab->stub_error = TRUE;
11059           return FALSE;
11060         }
11061
11062       if (info->emitrelocations)
11063         {
11064           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11065           if (r == NULL)
11066             return FALSE;
11067           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11068           if (bfd_big_endian (info->output_bfd))
11069             r[0].r_offset += 2;
11070           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11071             r[0].r_offset += 4;
11072           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11073           r[0].r_addend = dest;
11074           if (PPC_HA (off) != 0)
11075             {
11076               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11077               r[1].r_offset = r[0].r_offset + 4;
11078               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11079               r[1].r_addend = r[0].r_addend;
11080             }
11081         }
11082
11083       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11084         {
11085           if (PPC_HA (off) != 0)
11086             {
11087               size = 16;
11088               bfd_put_32 (htab->params->stub_bfd,
11089                           ADDIS_R12_R2 | PPC_HA (off), loc);
11090               loc += 4;
11091               bfd_put_32 (htab->params->stub_bfd,
11092                           LD_R12_0R12 | PPC_LO (off), loc);
11093             }
11094           else
11095             {
11096               size = 12;
11097               bfd_put_32 (htab->params->stub_bfd,
11098                           LD_R12_0R2 | PPC_LO (off), loc);
11099             }
11100         }
11101       else
11102         {
11103           bfd_vma r2off = get_r2off (info, stub_entry);
11104
11105           if (r2off == (bfd_vma) -1)
11106             {
11107               htab->stub_error = TRUE;
11108               return FALSE;
11109             }
11110
11111           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11112           loc += 4;
11113           size = 16;
11114           if (PPC_HA (off) != 0)
11115             {
11116               size += 4;
11117               bfd_put_32 (htab->params->stub_bfd,
11118                           ADDIS_R12_R2 | PPC_HA (off), loc);
11119               loc += 4;
11120               bfd_put_32 (htab->params->stub_bfd,
11121                           LD_R12_0R12 | PPC_LO (off), loc);
11122             }
11123           else
11124             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11125
11126           if (PPC_HA (r2off) != 0)
11127             {
11128               size += 4;
11129               loc += 4;
11130               bfd_put_32 (htab->params->stub_bfd,
11131                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11132             }
11133           if (PPC_LO (r2off) != 0)
11134             {
11135               size += 4;
11136               loc += 4;
11137               bfd_put_32 (htab->params->stub_bfd,
11138                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11139             }
11140         }
11141       loc += 4;
11142       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11143       loc += 4;
11144       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11145       break;
11146
11147     case ppc_stub_plt_call:
11148     case ppc_stub_plt_call_r2save:
11149       if (stub_entry->h != NULL
11150           && stub_entry->h->is_func_descriptor
11151           && stub_entry->h->oh != NULL)
11152         {
11153           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11154
11155           /* If the old-ABI "dot-symbol" is undefined make it weak so
11156              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11157           if (fh->elf.root.type == bfd_link_hash_undefined
11158               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11159                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11160             fh->elf.root.type = bfd_link_hash_undefweak;
11161         }
11162
11163       /* Now build the stub.  */
11164       dest = stub_entry->plt_ent->plt.offset & ~1;
11165       if (dest >= (bfd_vma) -2)
11166         abort ();
11167
11168       plt = htab->elf.splt;
11169       if (!htab->elf.dynamic_sections_created
11170           || stub_entry->h == NULL
11171           || stub_entry->h->elf.dynindx == -1)
11172         plt = htab->elf.iplt;
11173
11174       dest += plt->output_offset + plt->output_section->vma;
11175
11176       if (stub_entry->h == NULL
11177           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11178         {
11179           Elf_Internal_Rela rela;
11180           bfd_byte *rl;
11181
11182           rela.r_offset = dest;
11183           if (htab->opd_abi)
11184             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11185           else
11186             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11187           rela.r_addend = (stub_entry->target_value
11188                            + stub_entry->target_section->output_offset
11189                            + stub_entry->target_section->output_section->vma);
11190
11191           rl = (htab->elf.irelplt->contents
11192                 + (htab->elf.irelplt->reloc_count++
11193                    * sizeof (Elf64_External_Rela)));
11194           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11195           stub_entry->plt_ent->plt.offset |= 1;
11196           htab->local_ifunc_resolver = 1;
11197         }
11198
11199       off = (dest
11200              - elf_gp (plt->output_section->owner)
11201              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11202
11203       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11204         {
11205           info->callbacks->einfo
11206             /* xgettext:c-format */
11207             (_("%P: linkage table error against `%T'\n"),
11208              stub_entry->h != NULL
11209              ? stub_entry->h->elf.root.root.string
11210              : "<local sym>");
11211           bfd_set_error (bfd_error_bad_value);
11212           htab->stub_error = TRUE;
11213           return FALSE;
11214         }
11215
11216       if (htab->params->plt_stub_align != 0)
11217         {
11218           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11219
11220           stub_entry->group->stub_sec->size += pad;
11221           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11222           loc += pad;
11223         }
11224
11225       r = NULL;
11226       if (info->emitrelocations)
11227         {
11228           r = get_relocs (stub_entry->group->stub_sec,
11229                           ((PPC_HA (off) != 0)
11230                            + (htab->opd_abi
11231                               ? 2 + (htab->params->plt_static_chain
11232                                      && PPC_HA (off + 16) == PPC_HA (off))
11233                               : 1)));
11234           if (r == NULL)
11235             return FALSE;
11236           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11237           if (bfd_big_endian (info->output_bfd))
11238             r[0].r_offset += 2;
11239           r[0].r_addend = dest;
11240         }
11241       if (stub_entry->h != NULL
11242           && (stub_entry->h == htab->tls_get_addr_fd
11243               || stub_entry->h == htab->tls_get_addr)
11244           && htab->params->tls_get_addr_opt)
11245         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11246       else
11247         p = build_plt_stub (htab, stub_entry, loc, off, r);
11248       size = p - loc;
11249       break;
11250
11251     case ppc_stub_save_res:
11252       return TRUE;
11253
11254     default:
11255       BFD_FAIL ();
11256       return FALSE;
11257     }
11258
11259   stub_entry->group->stub_sec->size += size;
11260
11261   if (htab->params->emit_stub_syms)
11262     {
11263       struct elf_link_hash_entry *h;
11264       size_t len1, len2;
11265       char *name;
11266       const char *const stub_str[] = { "long_branch",
11267                                        "long_branch_r2off",
11268                                        "plt_branch",
11269                                        "plt_branch_r2off",
11270                                        "plt_call",
11271                                        "plt_call" };
11272
11273       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11274       len2 = strlen (stub_entry->root.string);
11275       name = bfd_malloc (len1 + len2 + 2);
11276       if (name == NULL)
11277         return FALSE;
11278       memcpy (name, stub_entry->root.string, 9);
11279       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11280       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11281       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11282       if (h == NULL)
11283         return FALSE;
11284       if (h->root.type == bfd_link_hash_new)
11285         {
11286           h->root.type = bfd_link_hash_defined;
11287           h->root.u.def.section = stub_entry->group->stub_sec;
11288           h->root.u.def.value = stub_entry->stub_offset;
11289           h->ref_regular = 1;
11290           h->def_regular = 1;
11291           h->ref_regular_nonweak = 1;
11292           h->forced_local = 1;
11293           h->non_elf = 0;
11294           h->root.linker_def = 1;
11295         }
11296     }
11297
11298   return TRUE;
11299 }
11300
11301 /* As above, but don't actually build the stub.  Just bump offset so
11302    we know stub section sizes, and select plt_branch stubs where
11303    long_branch stubs won't do.  */
11304
11305 static bfd_boolean
11306 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11307 {
11308   struct ppc_stub_hash_entry *stub_entry;
11309   struct bfd_link_info *info;
11310   struct ppc_link_hash_table *htab;
11311   bfd_vma off;
11312   int size;
11313
11314   /* Massage our args to the form they really have.  */
11315   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11316   info = in_arg;
11317
11318   htab = ppc_hash_table (info);
11319   if (htab == NULL)
11320     return FALSE;
11321
11322   if (stub_entry->h != NULL
11323       && stub_entry->h->save_res
11324       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11325       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11326     {
11327       /* Don't make stubs to out-of-line register save/restore
11328          functions.  Instead, emit copies of the functions.  */
11329       stub_entry->group->needs_save_res = 1;
11330       stub_entry->stub_type = ppc_stub_save_res;
11331       return TRUE;
11332     }
11333
11334   if (stub_entry->stub_type == ppc_stub_plt_call
11335       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11336     {
11337       asection *plt;
11338       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11339       if (off >= (bfd_vma) -2)
11340         abort ();
11341       plt = htab->elf.splt;
11342       if (!htab->elf.dynamic_sections_created
11343           || stub_entry->h == NULL
11344           || stub_entry->h->elf.dynindx == -1)
11345         plt = htab->elf.iplt;
11346       off += (plt->output_offset
11347               + plt->output_section->vma
11348               - elf_gp (plt->output_section->owner)
11349               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11350
11351       size = plt_stub_size (htab, stub_entry, off);
11352       if (htab->params->plt_stub_align)
11353         size += plt_stub_pad (htab, stub_entry, off);
11354       if (info->emitrelocations)
11355         {
11356           stub_entry->group->stub_sec->reloc_count
11357             += ((PPC_HA (off) != 0)
11358                 + (htab->opd_abi
11359                    ? 2 + (htab->params->plt_static_chain
11360                           && PPC_HA (off + 16) == PPC_HA (off))
11361                    : 1));
11362           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11363         }
11364     }
11365   else
11366     {
11367       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11368          variants.  */
11369       bfd_vma r2off = 0;
11370       bfd_vma local_off = 0;
11371
11372       off = (stub_entry->target_value
11373              + stub_entry->target_section->output_offset
11374              + stub_entry->target_section->output_section->vma);
11375       off -= (stub_entry->group->stub_sec->size
11376               + stub_entry->group->stub_sec->output_offset
11377               + stub_entry->group->stub_sec->output_section->vma);
11378
11379       /* Reset the stub type from the plt variant in case we now
11380          can reach with a shorter stub.  */
11381       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11382         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11383
11384       size = 4;
11385       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11386         {
11387           r2off = get_r2off (info, stub_entry);
11388           if (r2off == (bfd_vma) -1)
11389             {
11390               htab->stub_error = TRUE;
11391               return FALSE;
11392             }
11393           size = 8;
11394           if (PPC_HA (r2off) != 0)
11395             size += 4;
11396           if (PPC_LO (r2off) != 0)
11397             size += 4;
11398           off -= size - 4;
11399         }
11400
11401       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11402
11403       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11404          Do the same for -R objects without function descriptors.  */
11405       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11406           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11407               && r2off == 0
11408               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11409         {
11410           struct ppc_branch_hash_entry *br_entry;
11411
11412           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11413                                              stub_entry->root.string + 9,
11414                                              TRUE, FALSE);
11415           if (br_entry == NULL)
11416             {
11417               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11418                                       stub_entry->root.string);
11419               htab->stub_error = TRUE;
11420               return FALSE;
11421             }
11422
11423           if (br_entry->iter != htab->stub_iteration)
11424             {
11425               br_entry->iter = htab->stub_iteration;
11426               br_entry->offset = htab->brlt->size;
11427               htab->brlt->size += 8;
11428
11429               if (htab->relbrlt != NULL)
11430                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11431               else if (info->emitrelocations)
11432                 {
11433                   htab->brlt->reloc_count += 1;
11434                   htab->brlt->flags |= SEC_RELOC;
11435                 }
11436             }
11437
11438           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11439           off = (br_entry->offset
11440                  + htab->brlt->output_offset
11441                  + htab->brlt->output_section->vma
11442                  - elf_gp (htab->brlt->output_section->owner)
11443                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11444
11445           if (info->emitrelocations)
11446             {
11447               stub_entry->group->stub_sec->reloc_count
11448                 += 1 + (PPC_HA (off) != 0);
11449               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11450             }
11451
11452           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11453             {
11454               size = 12;
11455               if (PPC_HA (off) != 0)
11456                 size = 16;
11457             }
11458           else
11459             {
11460               size = 16;
11461               if (PPC_HA (off) != 0)
11462                 size += 4;
11463
11464               if (PPC_HA (r2off) != 0)
11465                 size += 4;
11466               if (PPC_LO (r2off) != 0)
11467                 size += 4;
11468             }
11469         }
11470       else if (info->emitrelocations)
11471         {
11472           stub_entry->group->stub_sec->reloc_count += 1;
11473           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11474         }
11475     }
11476
11477   stub_entry->group->stub_sec->size += size;
11478   return TRUE;
11479 }
11480
11481 /* Set up various things so that we can make a list of input sections
11482    for each output section included in the link.  Returns -1 on error,
11483    0 when no stubs will be needed, and 1 on success.  */
11484
11485 int
11486 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11487 {
11488   unsigned int id;
11489   bfd_size_type amt;
11490   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11491
11492   if (htab == NULL)
11493     return -1;
11494
11495   htab->sec_info_arr_size = bfd_get_next_section_id ();
11496   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11497   htab->sec_info = bfd_zmalloc (amt);
11498   if (htab->sec_info == NULL)
11499     return -1;
11500
11501   /* Set toc_off for com, und, abs and ind sections.  */
11502   for (id = 0; id < 3; id++)
11503     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11504
11505   return 1;
11506 }
11507
11508 /* Set up for first pass at multitoc partitioning.  */
11509
11510 void
11511 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11512 {
11513   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11514
11515   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11516   htab->toc_bfd = NULL;
11517   htab->toc_first_sec = NULL;
11518 }
11519
11520 /* The linker repeatedly calls this function for each TOC input section
11521    and linker generated GOT section.  Group input bfds such that the toc
11522    within a group is less than 64k in size.  */
11523
11524 bfd_boolean
11525 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11526 {
11527   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11528   bfd_vma addr, off, limit;
11529
11530   if (htab == NULL)
11531     return FALSE;
11532
11533   if (!htab->second_toc_pass)
11534     {
11535       /* Keep track of the first .toc or .got section for this input bfd.  */
11536       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11537
11538       if (new_bfd)
11539         {
11540           htab->toc_bfd = isec->owner;
11541           htab->toc_first_sec = isec;
11542         }
11543
11544       addr = isec->output_offset + isec->output_section->vma;
11545       off = addr - htab->toc_curr;
11546       limit = 0x80008000;
11547       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11548         limit = 0x10000;
11549       if (off + isec->size > limit)
11550         {
11551           addr = (htab->toc_first_sec->output_offset
11552                   + htab->toc_first_sec->output_section->vma);
11553           htab->toc_curr = addr;
11554           htab->toc_curr &= -TOC_BASE_ALIGN;
11555         }
11556
11557       /* toc_curr is the base address of this toc group.  Set elf_gp
11558          for the input section to be the offset relative to the
11559          output toc base plus 0x8000.  Making the input elf_gp an
11560          offset allows us to move the toc as a whole without
11561          recalculating input elf_gp.  */
11562       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11563       off += TOC_BASE_OFF;
11564
11565       /* Die if someone uses a linker script that doesn't keep input
11566          file .toc and .got together.  */
11567       if (new_bfd
11568           && elf_gp (isec->owner) != 0
11569           && elf_gp (isec->owner) != off)
11570         return FALSE;
11571
11572       elf_gp (isec->owner) = off;
11573       return TRUE;
11574     }
11575
11576   /* During the second pass toc_first_sec points to the start of
11577      a toc group, and toc_curr is used to track the old elf_gp.
11578      We use toc_bfd to ensure we only look at each bfd once.  */
11579   if (htab->toc_bfd == isec->owner)
11580     return TRUE;
11581   htab->toc_bfd = isec->owner;
11582
11583   if (htab->toc_first_sec == NULL
11584       || htab->toc_curr != elf_gp (isec->owner))
11585     {
11586       htab->toc_curr = elf_gp (isec->owner);
11587       htab->toc_first_sec = isec;
11588     }
11589   addr = (htab->toc_first_sec->output_offset
11590           + htab->toc_first_sec->output_section->vma);
11591   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11592   elf_gp (isec->owner) = off;
11593
11594   return TRUE;
11595 }
11596
11597 /* Called via elf_link_hash_traverse to merge GOT entries for global
11598    symbol H.  */
11599
11600 static bfd_boolean
11601 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11602 {
11603   if (h->root.type == bfd_link_hash_indirect)
11604     return TRUE;
11605
11606   merge_got_entries (&h->got.glist);
11607
11608   return TRUE;
11609 }
11610
11611 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11612    symbol H.  */
11613
11614 static bfd_boolean
11615 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11616 {
11617   struct got_entry *gent;
11618
11619   if (h->root.type == bfd_link_hash_indirect)
11620     return TRUE;
11621
11622   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11623     if (!gent->is_indirect)
11624       allocate_got (h, (struct bfd_link_info *) inf, gent);
11625   return TRUE;
11626 }
11627
11628 /* Called on the first multitoc pass after the last call to
11629    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11630    entries.  */
11631
11632 bfd_boolean
11633 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11634 {
11635   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11636   struct bfd *ibfd, *ibfd2;
11637   bfd_boolean done_something;
11638
11639   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11640
11641   if (!htab->do_multi_toc)
11642     return FALSE;
11643
11644   /* Merge global sym got entries within a toc group.  */
11645   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11646
11647   /* And tlsld_got.  */
11648   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11649     {
11650       struct got_entry *ent, *ent2;
11651
11652       if (!is_ppc64_elf (ibfd))
11653         continue;
11654
11655       ent = ppc64_tlsld_got (ibfd);
11656       if (!ent->is_indirect
11657           && ent->got.offset != (bfd_vma) -1)
11658         {
11659           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11660             {
11661               if (!is_ppc64_elf (ibfd2))
11662                 continue;
11663
11664               ent2 = ppc64_tlsld_got (ibfd2);
11665               if (!ent2->is_indirect
11666                   && ent2->got.offset != (bfd_vma) -1
11667                   && elf_gp (ibfd2) == elf_gp (ibfd))
11668                 {
11669                   ent2->is_indirect = TRUE;
11670                   ent2->got.ent = ent;
11671                 }
11672             }
11673         }
11674     }
11675
11676   /* Zap sizes of got sections.  */
11677   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11678   htab->elf.irelplt->size -= htab->got_reli_size;
11679   htab->got_reli_size = 0;
11680
11681   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11682     {
11683       asection *got, *relgot;
11684
11685       if (!is_ppc64_elf (ibfd))
11686         continue;
11687
11688       got = ppc64_elf_tdata (ibfd)->got;
11689       if (got != NULL)
11690         {
11691           got->rawsize = got->size;
11692           got->size = 0;
11693           relgot = ppc64_elf_tdata (ibfd)->relgot;
11694           relgot->rawsize = relgot->size;
11695           relgot->size = 0;
11696         }
11697     }
11698
11699   /* Now reallocate the got, local syms first.  We don't need to
11700      allocate section contents again since we never increase size.  */
11701   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11702     {
11703       struct got_entry **lgot_ents;
11704       struct got_entry **end_lgot_ents;
11705       struct plt_entry **local_plt;
11706       struct plt_entry **end_local_plt;
11707       unsigned char *lgot_masks;
11708       bfd_size_type locsymcount;
11709       Elf_Internal_Shdr *symtab_hdr;
11710       asection *s;
11711
11712       if (!is_ppc64_elf (ibfd))
11713         continue;
11714
11715       lgot_ents = elf_local_got_ents (ibfd);
11716       if (!lgot_ents)
11717         continue;
11718
11719       symtab_hdr = &elf_symtab_hdr (ibfd);
11720       locsymcount = symtab_hdr->sh_info;
11721       end_lgot_ents = lgot_ents + locsymcount;
11722       local_plt = (struct plt_entry **) end_lgot_ents;
11723       end_local_plt = local_plt + locsymcount;
11724       lgot_masks = (unsigned char *) end_local_plt;
11725       s = ppc64_elf_tdata (ibfd)->got;
11726       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11727         {
11728           struct got_entry *ent;
11729
11730           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11731             {
11732               unsigned int ent_size = 8;
11733               unsigned int rel_size = sizeof (Elf64_External_Rela);
11734
11735               ent->got.offset = s->size;
11736               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11737                 {
11738                   ent_size *= 2;
11739                   rel_size *= 2;
11740                 }
11741               s->size += ent_size;
11742               if ((*lgot_masks & PLT_IFUNC) != 0)
11743                 {
11744                   htab->elf.irelplt->size += rel_size;
11745                   htab->got_reli_size += rel_size;
11746                 }
11747               else if (bfd_link_pic (info))
11748                 {
11749                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11750                   srel->size += rel_size;
11751                 }
11752             }
11753         }
11754     }
11755
11756   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11757
11758   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11759     {
11760       struct got_entry *ent;
11761
11762       if (!is_ppc64_elf (ibfd))
11763         continue;
11764
11765       ent = ppc64_tlsld_got (ibfd);
11766       if (!ent->is_indirect
11767           && ent->got.offset != (bfd_vma) -1)
11768         {
11769           asection *s = ppc64_elf_tdata (ibfd)->got;
11770           ent->got.offset = s->size;
11771           s->size += 16;
11772           if (bfd_link_pic (info))
11773             {
11774               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11775               srel->size += sizeof (Elf64_External_Rela);
11776             }
11777         }
11778     }
11779
11780   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11781   if (!done_something)
11782     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11783       {
11784         asection *got;
11785
11786         if (!is_ppc64_elf (ibfd))
11787           continue;
11788
11789         got = ppc64_elf_tdata (ibfd)->got;
11790         if (got != NULL)
11791           {
11792             done_something = got->rawsize != got->size;
11793             if (done_something)
11794               break;
11795           }
11796       }
11797
11798   if (done_something)
11799     (*htab->params->layout_sections_again) ();
11800
11801   /* Set up for second pass over toc sections to recalculate elf_gp
11802      on input sections.  */
11803   htab->toc_bfd = NULL;
11804   htab->toc_first_sec = NULL;
11805   htab->second_toc_pass = TRUE;
11806   return done_something;
11807 }
11808
11809 /* Called after second pass of multitoc partitioning.  */
11810
11811 void
11812 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11813 {
11814   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11815
11816   /* After the second pass, toc_curr tracks the TOC offset used
11817      for code sections below in ppc64_elf_next_input_section.  */
11818   htab->toc_curr = TOC_BASE_OFF;
11819 }
11820
11821 /* No toc references were found in ISEC.  If the code in ISEC makes no
11822    calls, then there's no need to use toc adjusting stubs when branching
11823    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11824    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11825    needed, and 2 if a cyclical call-graph was found but no other reason
11826    for a stub was detected.  If called from the top level, a return of
11827    2 means the same as a return of 0.  */
11828
11829 static int
11830 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11831 {
11832   int ret;
11833
11834   /* Mark this section as checked.  */
11835   isec->call_check_done = 1;
11836
11837   /* We know none of our code bearing sections will need toc stubs.  */
11838   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11839     return 0;
11840
11841   if (isec->size == 0)
11842     return 0;
11843
11844   if (isec->output_section == NULL)
11845     return 0;
11846
11847   ret = 0;
11848   if (isec->reloc_count != 0)
11849     {
11850       Elf_Internal_Rela *relstart, *rel;
11851       Elf_Internal_Sym *local_syms;
11852       struct ppc_link_hash_table *htab;
11853
11854       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11855                                             info->keep_memory);
11856       if (relstart == NULL)
11857         return -1;
11858
11859       /* Look for branches to outside of this section.  */
11860       local_syms = NULL;
11861       htab = ppc_hash_table (info);
11862       if (htab == NULL)
11863         return -1;
11864
11865       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11866         {
11867           enum elf_ppc64_reloc_type r_type;
11868           unsigned long r_symndx;
11869           struct elf_link_hash_entry *h;
11870           struct ppc_link_hash_entry *eh;
11871           Elf_Internal_Sym *sym;
11872           asection *sym_sec;
11873           struct _opd_sec_data *opd;
11874           bfd_vma sym_value;
11875           bfd_vma dest;
11876
11877           r_type = ELF64_R_TYPE (rel->r_info);
11878           if (r_type != R_PPC64_REL24
11879               && r_type != R_PPC64_REL14
11880               && r_type != R_PPC64_REL14_BRTAKEN
11881               && r_type != R_PPC64_REL14_BRNTAKEN)
11882             continue;
11883
11884           r_symndx = ELF64_R_SYM (rel->r_info);
11885           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11886                           isec->owner))
11887             {
11888               ret = -1;
11889               break;
11890             }
11891
11892           /* Calls to dynamic lib functions go through a plt call stub
11893              that uses r2.  */
11894           eh = (struct ppc_link_hash_entry *) h;
11895           if (eh != NULL
11896               && (eh->elf.plt.plist != NULL
11897                   || (eh->oh != NULL
11898                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11899             {
11900               ret = 1;
11901               break;
11902             }
11903
11904           if (sym_sec == NULL)
11905             /* Ignore other undefined symbols.  */
11906             continue;
11907
11908           /* Assume branches to other sections not included in the
11909              link need stubs too, to cover -R and absolute syms.  */
11910           if (sym_sec->output_section == NULL)
11911             {
11912               ret = 1;
11913               break;
11914             }
11915
11916           if (h == NULL)
11917             sym_value = sym->st_value;
11918           else
11919             {
11920               if (h->root.type != bfd_link_hash_defined
11921                   && h->root.type != bfd_link_hash_defweak)
11922                 abort ();
11923               sym_value = h->root.u.def.value;
11924             }
11925           sym_value += rel->r_addend;
11926
11927           /* If this branch reloc uses an opd sym, find the code section.  */
11928           opd = get_opd_info (sym_sec);
11929           if (opd != NULL)
11930             {
11931               if (h == NULL && opd->adjust != NULL)
11932                 {
11933                   long adjust;
11934
11935                   adjust = opd->adjust[OPD_NDX (sym_value)];
11936                   if (adjust == -1)
11937                     /* Assume deleted functions won't ever be called.  */
11938                     continue;
11939                   sym_value += adjust;
11940                 }
11941
11942               dest = opd_entry_value (sym_sec, sym_value,
11943                                       &sym_sec, NULL, FALSE);
11944               if (dest == (bfd_vma) -1)
11945                 continue;
11946             }
11947           else
11948             dest = (sym_value
11949                     + sym_sec->output_offset
11950                     + sym_sec->output_section->vma);
11951
11952           /* Ignore branch to self.  */
11953           if (sym_sec == isec)
11954             continue;
11955
11956           /* If the called function uses the toc, we need a stub.  */
11957           if (sym_sec->has_toc_reloc
11958               || sym_sec->makes_toc_func_call)
11959             {
11960               ret = 1;
11961               break;
11962             }
11963
11964           /* Assume any branch that needs a long branch stub might in fact
11965              need a plt_branch stub.  A plt_branch stub uses r2.  */
11966           else if (dest - (isec->output_offset
11967                            + isec->output_section->vma
11968                            + rel->r_offset) + (1 << 25)
11969                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11970                                                              ? h->other
11971                                                              : sym->st_other))
11972             {
11973               ret = 1;
11974               break;
11975             }
11976
11977           /* If calling back to a section in the process of being
11978              tested, we can't say for sure that no toc adjusting stubs
11979              are needed, so don't return zero.  */
11980           else if (sym_sec->call_check_in_progress)
11981             ret = 2;
11982
11983           /* Branches to another section that itself doesn't have any TOC
11984              references are OK.  Recursively call ourselves to check.  */
11985           else if (!sym_sec->call_check_done)
11986             {
11987               int recur;
11988
11989               /* Mark current section as indeterminate, so that other
11990                  sections that call back to current won't be marked as
11991                  known.  */
11992               isec->call_check_in_progress = 1;
11993               recur = toc_adjusting_stub_needed (info, sym_sec);
11994               isec->call_check_in_progress = 0;
11995
11996               if (recur != 0)
11997                 {
11998                   ret = recur;
11999                   if (recur != 2)
12000                     break;
12001                 }
12002             }
12003         }
12004
12005       if (local_syms != NULL
12006           && (elf_symtab_hdr (isec->owner).contents
12007               != (unsigned char *) local_syms))
12008         free (local_syms);
12009       if (elf_section_data (isec)->relocs != relstart)
12010         free (relstart);
12011     }
12012
12013   if ((ret & 1) == 0
12014       && isec->map_head.s != NULL
12015       && (strcmp (isec->output_section->name, ".init") == 0
12016           || strcmp (isec->output_section->name, ".fini") == 0))
12017     {
12018       if (isec->map_head.s->has_toc_reloc
12019           || isec->map_head.s->makes_toc_func_call)
12020         ret = 1;
12021       else if (!isec->map_head.s->call_check_done)
12022         {
12023           int recur;
12024           isec->call_check_in_progress = 1;
12025           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12026           isec->call_check_in_progress = 0;
12027           if (recur != 0)
12028             ret = recur;
12029         }
12030     }
12031
12032   if (ret == 1)
12033     isec->makes_toc_func_call = 1;
12034
12035   return ret;
12036 }
12037
12038 /* The linker repeatedly calls this function for each input section,
12039    in the order that input sections are linked into output sections.
12040    Build lists of input sections to determine groupings between which
12041    we may insert linker stubs.  */
12042
12043 bfd_boolean
12044 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12045 {
12046   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12047
12048   if (htab == NULL)
12049     return FALSE;
12050
12051   if ((isec->output_section->flags & SEC_CODE) != 0
12052       && isec->output_section->id < htab->sec_info_arr_size)
12053     {
12054       /* This happens to make the list in reverse order,
12055          which is what we want.  */
12056       htab->sec_info[isec->id].u.list
12057         = htab->sec_info[isec->output_section->id].u.list;
12058       htab->sec_info[isec->output_section->id].u.list = isec;
12059     }
12060
12061   if (htab->multi_toc_needed)
12062     {
12063       /* Analyse sections that aren't already flagged as needing a
12064          valid toc pointer.  Exclude .fixup for the linux kernel.
12065          .fixup contains branches, but only back to the function that
12066          hit an exception.  */
12067       if (!(isec->has_toc_reloc
12068             || (isec->flags & SEC_CODE) == 0
12069             || strcmp (isec->name, ".fixup") == 0
12070             || isec->call_check_done))
12071         {
12072           if (toc_adjusting_stub_needed (info, isec) < 0)
12073             return FALSE;
12074         }
12075       /* Make all sections use the TOC assigned for this object file.
12076          This will be wrong for pasted sections;  We fix that in
12077          check_pasted_section().  */
12078       if (elf_gp (isec->owner) != 0)
12079         htab->toc_curr = elf_gp (isec->owner);
12080     }
12081
12082   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12083   return TRUE;
12084 }
12085
12086 /* Check that all .init and .fini sections use the same toc, if they
12087    have toc relocs.  */
12088
12089 static bfd_boolean
12090 check_pasted_section (struct bfd_link_info *info, const char *name)
12091 {
12092   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12093
12094   if (o != NULL)
12095     {
12096       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12097       bfd_vma toc_off = 0;
12098       asection *i;
12099
12100       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12101         if (i->has_toc_reloc)
12102           {
12103             if (toc_off == 0)
12104               toc_off = htab->sec_info[i->id].toc_off;
12105             else if (toc_off != htab->sec_info[i->id].toc_off)
12106               return FALSE;
12107           }
12108
12109       if (toc_off == 0)
12110         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12111           if (i->makes_toc_func_call)
12112             {
12113               toc_off = htab->sec_info[i->id].toc_off;
12114               break;
12115             }
12116
12117       /* Make sure the whole pasted function uses the same toc offset.  */
12118       if (toc_off != 0)
12119         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12120           htab->sec_info[i->id].toc_off = toc_off;
12121     }
12122   return TRUE;
12123 }
12124
12125 bfd_boolean
12126 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12127 {
12128   return (check_pasted_section (info, ".init")
12129           & check_pasted_section (info, ".fini"));
12130 }
12131
12132 /* See whether we can group stub sections together.  Grouping stub
12133    sections may result in fewer stubs.  More importantly, we need to
12134    put all .init* and .fini* stubs at the beginning of the .init or
12135    .fini output sections respectively, because glibc splits the
12136    _init and _fini functions into multiple parts.  Putting a stub in
12137    the middle of a function is not a good idea.  */
12138
12139 static bfd_boolean
12140 group_sections (struct bfd_link_info *info,
12141                 bfd_size_type stub_group_size,
12142                 bfd_boolean stubs_always_before_branch)
12143 {
12144   struct ppc_link_hash_table *htab;
12145   asection *osec;
12146   bfd_boolean suppress_size_errors;
12147
12148   htab = ppc_hash_table (info);
12149   if (htab == NULL)
12150     return FALSE;
12151
12152   suppress_size_errors = FALSE;
12153   if (stub_group_size == 1)
12154     {
12155       /* Default values.  */
12156       if (stubs_always_before_branch)
12157         stub_group_size = 0x1e00000;
12158       else
12159         stub_group_size = 0x1c00000;
12160       suppress_size_errors = TRUE;
12161     }
12162
12163   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12164     {
12165       asection *tail;
12166
12167       if (osec->id >= htab->sec_info_arr_size)
12168         continue;
12169
12170       tail = htab->sec_info[osec->id].u.list;
12171       while (tail != NULL)
12172         {
12173           asection *curr;
12174           asection *prev;
12175           bfd_size_type total;
12176           bfd_boolean big_sec;
12177           bfd_vma curr_toc;
12178           struct map_stub *group;
12179           bfd_size_type group_size;
12180
12181           curr = tail;
12182           total = tail->size;
12183           group_size = (ppc64_elf_section_data (tail) != NULL
12184                         && ppc64_elf_section_data (tail)->has_14bit_branch
12185                         ? stub_group_size >> 10 : stub_group_size);
12186
12187           big_sec = total > group_size;
12188           if (big_sec && !suppress_size_errors)
12189             /* xgettext:c-format */
12190             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12191                                 tail->owner, tail);
12192           curr_toc = htab->sec_info[tail->id].toc_off;
12193
12194           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12195                  && ((total += curr->output_offset - prev->output_offset)
12196                      < (ppc64_elf_section_data (prev) != NULL
12197                         && ppc64_elf_section_data (prev)->has_14bit_branch
12198                         ? (group_size = stub_group_size >> 10) : group_size))
12199                  && htab->sec_info[prev->id].toc_off == curr_toc)
12200             curr = prev;
12201
12202           /* OK, the size from the start of CURR to the end is less
12203              than group_size and thus can be handled by one stub
12204              section.  (or the tail section is itself larger than
12205              group_size, in which case we may be toast.)  We should
12206              really be keeping track of the total size of stubs added
12207              here, as stubs contribute to the final output section
12208              size.  That's a little tricky, and this way will only
12209              break if stubs added make the total size more than 2^25,
12210              ie. for the default stub_group_size, if stubs total more
12211              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12212           group = bfd_alloc (curr->owner, sizeof (*group));
12213           if (group == NULL)
12214             return FALSE;
12215           group->link_sec = curr;
12216           group->stub_sec = NULL;
12217           group->needs_save_res = 0;
12218           group->next = htab->group;
12219           htab->group = group;
12220           do
12221             {
12222               prev = htab->sec_info[tail->id].u.list;
12223               /* Set up this stub group.  */
12224               htab->sec_info[tail->id].u.group = group;
12225             }
12226           while (tail != curr && (tail = prev) != NULL);
12227
12228           /* But wait, there's more!  Input sections up to group_size
12229              bytes before the stub section can be handled by it too.
12230              Don't do this if we have a really large section after the
12231              stubs, as adding more stubs increases the chance that
12232              branches may not reach into the stub section.  */
12233           if (!stubs_always_before_branch && !big_sec)
12234             {
12235               total = 0;
12236               while (prev != NULL
12237                      && ((total += tail->output_offset - prev->output_offset)
12238                          < (ppc64_elf_section_data (prev) != NULL
12239                             && ppc64_elf_section_data (prev)->has_14bit_branch
12240                             ? (group_size = stub_group_size >> 10) : group_size))
12241                      && htab->sec_info[prev->id].toc_off == curr_toc)
12242                 {
12243                   tail = prev;
12244                   prev = htab->sec_info[tail->id].u.list;
12245                   htab->sec_info[tail->id].u.group = group;
12246                 }
12247             }
12248           tail = prev;
12249         }
12250     }
12251   return TRUE;
12252 }
12253
12254 static const unsigned char glink_eh_frame_cie[] =
12255 {
12256   0, 0, 0, 16,                          /* length.  */
12257   0, 0, 0, 0,                           /* id.  */
12258   1,                                    /* CIE version.  */
12259   'z', 'R', 0,                          /* Augmentation string.  */
12260   4,                                    /* Code alignment.  */
12261   0x78,                                 /* Data alignment.  */
12262   65,                                   /* RA reg.  */
12263   1,                                    /* Augmentation size.  */
12264   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12265   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12266 };
12267
12268 /* Stripping output sections is normally done before dynamic section
12269    symbols have been allocated.  This function is called later, and
12270    handles cases like htab->brlt which is mapped to its own output
12271    section.  */
12272
12273 static void
12274 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12275 {
12276   if (isec->size == 0
12277       && isec->output_section->size == 0
12278       && !(isec->output_section->flags & SEC_KEEP)
12279       && !bfd_section_removed_from_list (info->output_bfd,
12280                                          isec->output_section)
12281       && elf_section_data (isec->output_section)->dynindx == 0)
12282     {
12283       isec->output_section->flags |= SEC_EXCLUDE;
12284       bfd_section_list_remove (info->output_bfd, isec->output_section);
12285       info->output_bfd->section_count--;
12286     }
12287 }
12288
12289 /* Determine and set the size of the stub section for a final link.
12290
12291    The basic idea here is to examine all the relocations looking for
12292    PC-relative calls to a target that is unreachable with a "bl"
12293    instruction.  */
12294
12295 bfd_boolean
12296 ppc64_elf_size_stubs (struct bfd_link_info *info)
12297 {
12298   bfd_size_type stub_group_size;
12299   bfd_boolean stubs_always_before_branch;
12300   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12301
12302   if (htab == NULL)
12303     return FALSE;
12304
12305   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12306     htab->params->plt_thread_safe = 1;
12307   if (!htab->opd_abi)
12308     htab->params->plt_thread_safe = 0;
12309   else if (htab->params->plt_thread_safe == -1)
12310     {
12311       static const char *const thread_starter[] =
12312         {
12313           "pthread_create",
12314           /* libstdc++ */
12315           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12316           /* librt */
12317           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12318           "mq_notify", "create_timer",
12319           /* libanl */
12320           "getaddrinfo_a",
12321           /* libgomp */
12322           "GOMP_parallel",
12323           "GOMP_parallel_start",
12324           "GOMP_parallel_loop_static",
12325           "GOMP_parallel_loop_static_start",
12326           "GOMP_parallel_loop_dynamic",
12327           "GOMP_parallel_loop_dynamic_start",
12328           "GOMP_parallel_loop_guided",
12329           "GOMP_parallel_loop_guided_start",
12330           "GOMP_parallel_loop_runtime",
12331           "GOMP_parallel_loop_runtime_start",
12332           "GOMP_parallel_sections",
12333           "GOMP_parallel_sections_start",
12334           /* libgo */
12335           "__go_go",
12336         };
12337       unsigned i;
12338
12339       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12340         {
12341           struct elf_link_hash_entry *h;
12342           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12343                                     FALSE, FALSE, TRUE);
12344           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12345           if (htab->params->plt_thread_safe)
12346             break;
12347         }
12348     }
12349   stubs_always_before_branch = htab->params->group_size < 0;
12350   if (htab->params->group_size < 0)
12351     stub_group_size = -htab->params->group_size;
12352   else
12353     stub_group_size = htab->params->group_size;
12354
12355   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12356     return FALSE;
12357
12358 #define STUB_SHRINK_ITER 20
12359   /* Loop until no stubs added.  After iteration 20 of this loop we may
12360      exit on a stub section shrinking.  This is to break out of a
12361      pathological case where adding stubs on one iteration decreases
12362      section gaps (perhaps due to alignment), which then requires
12363      fewer or smaller stubs on the next iteration.  */
12364
12365   while (1)
12366     {
12367       bfd *input_bfd;
12368       unsigned int bfd_indx;
12369       struct map_stub *group;
12370       asection *stub_sec;
12371
12372       htab->stub_iteration += 1;
12373
12374       for (input_bfd = info->input_bfds, bfd_indx = 0;
12375            input_bfd != NULL;
12376            input_bfd = input_bfd->link.next, bfd_indx++)
12377         {
12378           Elf_Internal_Shdr *symtab_hdr;
12379           asection *section;
12380           Elf_Internal_Sym *local_syms = NULL;
12381
12382           if (!is_ppc64_elf (input_bfd))
12383             continue;
12384
12385           /* We'll need the symbol table in a second.  */
12386           symtab_hdr = &elf_symtab_hdr (input_bfd);
12387           if (symtab_hdr->sh_info == 0)
12388             continue;
12389
12390           /* Walk over each section attached to the input bfd.  */
12391           for (section = input_bfd->sections;
12392                section != NULL;
12393                section = section->next)
12394             {
12395               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12396
12397               /* If there aren't any relocs, then there's nothing more
12398                  to do.  */
12399               if ((section->flags & SEC_RELOC) == 0
12400                   || (section->flags & SEC_ALLOC) == 0
12401                   || (section->flags & SEC_LOAD) == 0
12402                   || (section->flags & SEC_CODE) == 0
12403                   || section->reloc_count == 0)
12404                 continue;
12405
12406               /* If this section is a link-once section that will be
12407                  discarded, then don't create any stubs.  */
12408               if (section->output_section == NULL
12409                   || section->output_section->owner != info->output_bfd)
12410                 continue;
12411
12412               /* Get the relocs.  */
12413               internal_relocs
12414                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12415                                              info->keep_memory);
12416               if (internal_relocs == NULL)
12417                 goto error_ret_free_local;
12418
12419               /* Now examine each relocation.  */
12420               irela = internal_relocs;
12421               irelaend = irela + section->reloc_count;
12422               for (; irela < irelaend; irela++)
12423                 {
12424                   enum elf_ppc64_reloc_type r_type;
12425                   unsigned int r_indx;
12426                   enum ppc_stub_type stub_type;
12427                   struct ppc_stub_hash_entry *stub_entry;
12428                   asection *sym_sec, *code_sec;
12429                   bfd_vma sym_value, code_value;
12430                   bfd_vma destination;
12431                   unsigned long local_off;
12432                   bfd_boolean ok_dest;
12433                   struct ppc_link_hash_entry *hash;
12434                   struct ppc_link_hash_entry *fdh;
12435                   struct elf_link_hash_entry *h;
12436                   Elf_Internal_Sym *sym;
12437                   char *stub_name;
12438                   const asection *id_sec;
12439                   struct _opd_sec_data *opd;
12440                   struct plt_entry *plt_ent;
12441
12442                   r_type = ELF64_R_TYPE (irela->r_info);
12443                   r_indx = ELF64_R_SYM (irela->r_info);
12444
12445                   if (r_type >= R_PPC64_max)
12446                     {
12447                       bfd_set_error (bfd_error_bad_value);
12448                       goto error_ret_free_internal;
12449                     }
12450
12451                   /* Only look for stubs on branch instructions.  */
12452                   if (r_type != R_PPC64_REL24
12453                       && r_type != R_PPC64_REL14
12454                       && r_type != R_PPC64_REL14_BRTAKEN
12455                       && r_type != R_PPC64_REL14_BRNTAKEN)
12456                     continue;
12457
12458                   /* Now determine the call target, its name, value,
12459                      section.  */
12460                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12461                                   r_indx, input_bfd))
12462                     goto error_ret_free_internal;
12463                   hash = (struct ppc_link_hash_entry *) h;
12464
12465                   ok_dest = FALSE;
12466                   fdh = NULL;
12467                   sym_value = 0;
12468                   if (hash == NULL)
12469                     {
12470                       sym_value = sym->st_value;
12471                       if (sym_sec != NULL
12472                           && sym_sec->output_section != NULL)
12473                         ok_dest = TRUE;
12474                     }
12475                   else if (hash->elf.root.type == bfd_link_hash_defined
12476                            || hash->elf.root.type == bfd_link_hash_defweak)
12477                     {
12478                       sym_value = hash->elf.root.u.def.value;
12479                       if (sym_sec->output_section != NULL)
12480                         ok_dest = TRUE;
12481                     }
12482                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12483                            || hash->elf.root.type == bfd_link_hash_undefined)
12484                     {
12485                       /* Recognise an old ABI func code entry sym, and
12486                          use the func descriptor sym instead if it is
12487                          defined.  */
12488                       if (hash->elf.root.root.string[0] == '.'
12489                           && hash->oh != NULL)
12490                         {
12491                           fdh = ppc_follow_link (hash->oh);
12492                           if (fdh->elf.root.type == bfd_link_hash_defined
12493                               || fdh->elf.root.type == bfd_link_hash_defweak)
12494                             {
12495                               sym_sec = fdh->elf.root.u.def.section;
12496                               sym_value = fdh->elf.root.u.def.value;
12497                               if (sym_sec->output_section != NULL)
12498                                 ok_dest = TRUE;
12499                             }
12500                           else
12501                             fdh = NULL;
12502                         }
12503                     }
12504                   else
12505                     {
12506                       bfd_set_error (bfd_error_bad_value);
12507                       goto error_ret_free_internal;
12508                     }
12509
12510                   destination = 0;
12511                   local_off = 0;
12512                   if (ok_dest)
12513                     {
12514                       sym_value += irela->r_addend;
12515                       destination = (sym_value
12516                                      + sym_sec->output_offset
12517                                      + sym_sec->output_section->vma);
12518                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12519                                                             ? hash->elf.other
12520                                                             : sym->st_other);
12521                     }
12522
12523                   code_sec = sym_sec;
12524                   code_value = sym_value;
12525                   opd = get_opd_info (sym_sec);
12526                   if (opd != NULL)
12527                     {
12528                       bfd_vma dest;
12529
12530                       if (hash == NULL && opd->adjust != NULL)
12531                         {
12532                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12533                           if (adjust == -1)
12534                             continue;
12535                           code_value += adjust;
12536                           sym_value += adjust;
12537                         }
12538                       dest = opd_entry_value (sym_sec, sym_value,
12539                                               &code_sec, &code_value, FALSE);
12540                       if (dest != (bfd_vma) -1)
12541                         {
12542                           destination = dest;
12543                           if (fdh != NULL)
12544                             {
12545                               /* Fixup old ABI sym to point at code
12546                                  entry.  */
12547                               hash->elf.root.type = bfd_link_hash_defweak;
12548                               hash->elf.root.u.def.section = code_sec;
12549                               hash->elf.root.u.def.value = code_value;
12550                             }
12551                         }
12552                     }
12553
12554                   /* Determine what (if any) linker stub is needed.  */
12555                   plt_ent = NULL;
12556                   stub_type = ppc_type_of_stub (section, irela, &hash,
12557                                                 &plt_ent, destination,
12558                                                 local_off);
12559
12560                   if (stub_type != ppc_stub_plt_call)
12561                     {
12562                       /* Check whether we need a TOC adjusting stub.
12563                          Since the linker pastes together pieces from
12564                          different object files when creating the
12565                          _init and _fini functions, it may be that a
12566                          call to what looks like a local sym is in
12567                          fact a call needing a TOC adjustment.  */
12568                       if (code_sec != NULL
12569                           && code_sec->output_section != NULL
12570                           && (htab->sec_info[code_sec->id].toc_off
12571                               != htab->sec_info[section->id].toc_off)
12572                           && (code_sec->has_toc_reloc
12573                               || code_sec->makes_toc_func_call))
12574                         stub_type = ppc_stub_long_branch_r2off;
12575                     }
12576
12577                   if (stub_type == ppc_stub_none)
12578                     continue;
12579
12580                   /* __tls_get_addr calls might be eliminated.  */
12581                   if (stub_type != ppc_stub_plt_call
12582                       && hash != NULL
12583                       && (hash == htab->tls_get_addr
12584                           || hash == htab->tls_get_addr_fd)
12585                       && section->has_tls_reloc
12586                       && irela != internal_relocs)
12587                     {
12588                       /* Get tls info.  */
12589                       unsigned char *tls_mask;
12590
12591                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12592                                          irela - 1, input_bfd))
12593                         goto error_ret_free_internal;
12594                       if (*tls_mask != 0)
12595                         continue;
12596                     }
12597
12598                   if (stub_type == ppc_stub_plt_call
12599                       && irela + 1 < irelaend
12600                       && irela[1].r_offset == irela->r_offset + 4
12601                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12602                     {
12603                       if (!tocsave_find (htab, INSERT,
12604                                          &local_syms, irela + 1, input_bfd))
12605                         goto error_ret_free_internal;
12606                     }
12607                   else if (stub_type == ppc_stub_plt_call)
12608                     stub_type = ppc_stub_plt_call_r2save;
12609
12610                   /* Support for grouping stub sections.  */
12611                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12612
12613                   /* Get the name of this stub.  */
12614                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12615                   if (!stub_name)
12616                     goto error_ret_free_internal;
12617
12618                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12619                                                      stub_name, FALSE, FALSE);
12620                   if (stub_entry != NULL)
12621                     {
12622                       /* The proper stub has already been created.  */
12623                       free (stub_name);
12624                       if (stub_type == ppc_stub_plt_call_r2save)
12625                         stub_entry->stub_type = stub_type;
12626                       continue;
12627                     }
12628
12629                   stub_entry = ppc_add_stub (stub_name, section, info);
12630                   if (stub_entry == NULL)
12631                     {
12632                       free (stub_name);
12633                     error_ret_free_internal:
12634                       if (elf_section_data (section)->relocs == NULL)
12635                         free (internal_relocs);
12636                     error_ret_free_local:
12637                       if (local_syms != NULL
12638                           && (symtab_hdr->contents
12639                               != (unsigned char *) local_syms))
12640                         free (local_syms);
12641                       return FALSE;
12642                     }
12643
12644                   stub_entry->stub_type = stub_type;
12645                   if (stub_type != ppc_stub_plt_call
12646                       && stub_type != ppc_stub_plt_call_r2save)
12647                     {
12648                       stub_entry->target_value = code_value;
12649                       stub_entry->target_section = code_sec;
12650                     }
12651                   else
12652                     {
12653                       stub_entry->target_value = sym_value;
12654                       stub_entry->target_section = sym_sec;
12655                     }
12656                   stub_entry->h = hash;
12657                   stub_entry->plt_ent = plt_ent;
12658                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12659
12660                   if (stub_entry->h != NULL)
12661                     htab->stub_globals += 1;
12662                 }
12663
12664               /* We're done with the internal relocs, free them.  */
12665               if (elf_section_data (section)->relocs != internal_relocs)
12666                 free (internal_relocs);
12667             }
12668
12669           if (local_syms != NULL
12670               && symtab_hdr->contents != (unsigned char *) local_syms)
12671             {
12672               if (!info->keep_memory)
12673                 free (local_syms);
12674               else
12675                 symtab_hdr->contents = (unsigned char *) local_syms;
12676             }
12677         }
12678
12679       /* We may have added some stubs.  Find out the new size of the
12680          stub sections.  */
12681       for (stub_sec = htab->params->stub_bfd->sections;
12682            stub_sec != NULL;
12683            stub_sec = stub_sec->next)
12684         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12685           {
12686             if (htab->stub_iteration <= STUB_SHRINK_ITER
12687                 || stub_sec->rawsize < stub_sec->size)
12688               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12689               stub_sec->rawsize = stub_sec->size;
12690             stub_sec->size = 0;
12691             stub_sec->reloc_count = 0;
12692             stub_sec->flags &= ~SEC_RELOC;
12693           }
12694
12695       htab->brlt->size = 0;
12696       htab->brlt->reloc_count = 0;
12697       htab->brlt->flags &= ~SEC_RELOC;
12698       if (htab->relbrlt != NULL)
12699         htab->relbrlt->size = 0;
12700
12701       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12702
12703       for (group = htab->group; group != NULL; group = group->next)
12704         if (group->needs_save_res)
12705           group->stub_sec->size += htab->sfpr->size;
12706
12707       if (info->emitrelocations
12708           && htab->glink != NULL && htab->glink->size != 0)
12709         {
12710           htab->glink->reloc_count = 1;
12711           htab->glink->flags |= SEC_RELOC;
12712         }
12713
12714       if (htab->glink_eh_frame != NULL
12715           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12716           && htab->glink_eh_frame->output_section->size != 0)
12717         {
12718           size_t size = 0, align = 4;
12719
12720           for (stub_sec = htab->params->stub_bfd->sections;
12721                stub_sec != NULL;
12722                stub_sec = stub_sec->next)
12723             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12724               size += (17 + align - 1) & -align;
12725           if (htab->glink != NULL && htab->glink->size != 0)
12726             size += (24 + align - 1) & -align;
12727           if (size != 0)
12728             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12729           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12730           size = (size + align - 1) & -align;
12731           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12732           htab->glink_eh_frame->size = size;
12733         }
12734
12735       if (htab->params->plt_stub_align != 0)
12736         for (stub_sec = htab->params->stub_bfd->sections;
12737              stub_sec != NULL;
12738              stub_sec = stub_sec->next)
12739           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12740             stub_sec->size = ((stub_sec->size
12741                                + (1 << htab->params->plt_stub_align) - 1)
12742                               & -(1 << htab->params->plt_stub_align));
12743
12744       for (stub_sec = htab->params->stub_bfd->sections;
12745            stub_sec != NULL;
12746            stub_sec = stub_sec->next)
12747         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12748             && stub_sec->rawsize != stub_sec->size
12749             && (htab->stub_iteration <= STUB_SHRINK_ITER
12750                 || stub_sec->rawsize < stub_sec->size))
12751           break;
12752
12753       if (stub_sec == NULL
12754           && (htab->glink_eh_frame == NULL
12755               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12756         break;
12757
12758       /* Ask the linker to do its stuff.  */
12759       (*htab->params->layout_sections_again) ();
12760     }
12761
12762   if (htab->glink_eh_frame != NULL
12763       && htab->glink_eh_frame->size != 0)
12764     {
12765       bfd_vma val;
12766       bfd_byte *p, *last_fde;
12767       size_t last_fde_len, size, align, pad;
12768       asection *stub_sec;
12769
12770       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12771       if (p == NULL)
12772         return FALSE;
12773       htab->glink_eh_frame->contents = p;
12774       last_fde = p;
12775       align = 4;
12776
12777       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12778       /* CIE length (rewrite in case little-endian).  */
12779       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12780       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12781       p += last_fde_len + 4;
12782
12783       for (stub_sec = htab->params->stub_bfd->sections;
12784            stub_sec != NULL;
12785            stub_sec = stub_sec->next)
12786         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12787           {
12788             last_fde = p;
12789             last_fde_len = ((17 + align - 1) & -align) - 4;
12790             /* FDE length.  */
12791             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12792             p += 4;
12793             /* CIE pointer.  */
12794             val = p - htab->glink_eh_frame->contents;
12795             bfd_put_32 (htab->elf.dynobj, val, p);
12796             p += 4;
12797             /* Offset to stub section, written later.  */
12798             p += 4;
12799             /* stub section size.  */
12800             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12801             p += 4;
12802             /* Augmentation.  */
12803             p += 1;
12804             /* Pad.  */
12805             p += ((17 + align - 1) & -align) - 17;
12806           }
12807       if (htab->glink != NULL && htab->glink->size != 0)
12808         {
12809           last_fde = p;
12810           last_fde_len = ((24 + align - 1) & -align) - 4;
12811           /* FDE length.  */
12812           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12813           p += 4;
12814           /* CIE pointer.  */
12815           val = p - htab->glink_eh_frame->contents;
12816           bfd_put_32 (htab->elf.dynobj, val, p);
12817           p += 4;
12818           /* Offset to .glink, written later.  */
12819           p += 4;
12820           /* .glink size.  */
12821           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12822           p += 4;
12823           /* Augmentation.  */
12824           p += 1;
12825
12826           *p++ = DW_CFA_advance_loc + 1;
12827           *p++ = DW_CFA_register;
12828           *p++ = 65;
12829           *p++ = htab->opd_abi ? 12 : 0;
12830           *p++ = DW_CFA_advance_loc + 4;
12831           *p++ = DW_CFA_restore_extended;
12832           *p++ = 65;
12833           p += ((24 + align - 1) & -align) - 24;
12834         }
12835       /* Subsume any padding into the last FDE if user .eh_frame
12836          sections are aligned more than glink_eh_frame.  Otherwise any
12837          zero padding will be seen as a terminator.  */
12838       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12839       size = p - htab->glink_eh_frame->contents;
12840       pad = ((size + align - 1) & -align) - size;
12841       htab->glink_eh_frame->size = size + pad;
12842       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12843     }
12844
12845   maybe_strip_output (info, htab->brlt);
12846   if (htab->glink_eh_frame != NULL)
12847     maybe_strip_output (info, htab->glink_eh_frame);
12848
12849   return TRUE;
12850 }
12851
12852 /* Called after we have determined section placement.  If sections
12853    move, we'll be called again.  Provide a value for TOCstart.  */
12854
12855 bfd_vma
12856 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12857 {
12858   asection *s;
12859   bfd_vma TOCstart, adjust;
12860
12861   if (info != NULL)
12862     {
12863       struct elf_link_hash_entry *h;
12864       struct elf_link_hash_table *htab = elf_hash_table (info);
12865
12866       if (is_elf_hash_table (htab)
12867           && htab->hgot != NULL)
12868         h = htab->hgot;
12869       else
12870         {
12871           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12872           if (is_elf_hash_table (htab))
12873             htab->hgot = h;
12874         }
12875       if (h != NULL
12876           && h->root.type == bfd_link_hash_defined
12877           && !h->root.linker_def
12878           && (!is_elf_hash_table (htab)
12879               || h->def_regular))
12880         {
12881           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12882                       + h->root.u.def.section->output_offset
12883                       + h->root.u.def.section->output_section->vma);
12884           _bfd_set_gp_value (obfd, TOCstart);
12885           return TOCstart;
12886         }
12887     }
12888
12889   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12890      order.  The TOC starts where the first of these sections starts.  */
12891   s = bfd_get_section_by_name (obfd, ".got");
12892   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12893     s = bfd_get_section_by_name (obfd, ".toc");
12894   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12895     s = bfd_get_section_by_name (obfd, ".tocbss");
12896   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12897     s = bfd_get_section_by_name (obfd, ".plt");
12898   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12899     {
12900       /* This may happen for
12901          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12902          .toc directive
12903          o  bad linker script
12904          o --gc-sections and empty TOC sections
12905
12906          FIXME: Warn user?  */
12907
12908       /* Look for a likely section.  We probably won't even be
12909          using TOCstart.  */
12910       for (s = obfd->sections; s != NULL; s = s->next)
12911         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12912                          | SEC_EXCLUDE))
12913             == (SEC_ALLOC | SEC_SMALL_DATA))
12914           break;
12915       if (s == NULL)
12916         for (s = obfd->sections; s != NULL; s = s->next)
12917           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12918               == (SEC_ALLOC | SEC_SMALL_DATA))
12919             break;
12920       if (s == NULL)
12921         for (s = obfd->sections; s != NULL; s = s->next)
12922           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12923               == SEC_ALLOC)
12924             break;
12925       if (s == NULL)
12926         for (s = obfd->sections; s != NULL; s = s->next)
12927           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12928             break;
12929     }
12930
12931   TOCstart = 0;
12932   if (s != NULL)
12933     TOCstart = s->output_section->vma + s->output_offset;
12934
12935   /* Force alignment.  */
12936   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12937   TOCstart -= adjust;
12938   _bfd_set_gp_value (obfd, TOCstart);
12939
12940   if (info != NULL && s != NULL)
12941     {
12942       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12943
12944       if (htab != NULL)
12945         {
12946           if (htab->elf.hgot != NULL)
12947             {
12948               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12949               htab->elf.hgot->root.u.def.section = s;
12950             }
12951         }
12952       else
12953         {
12954           struct bfd_link_hash_entry *bh = NULL;
12955           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12956                                             s, TOC_BASE_OFF - adjust,
12957                                             NULL, FALSE, FALSE, &bh);
12958         }
12959     }
12960   return TOCstart;
12961 }
12962
12963 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12964    write out any global entry stubs.  */
12965
12966 static bfd_boolean
12967 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12968 {
12969   struct bfd_link_info *info;
12970   struct ppc_link_hash_table *htab;
12971   struct plt_entry *pent;
12972   asection *s;
12973
12974   if (h->root.type == bfd_link_hash_indirect)
12975     return TRUE;
12976
12977   if (!h->pointer_equality_needed)
12978     return TRUE;
12979
12980   if (h->def_regular)
12981     return TRUE;
12982
12983   info = inf;
12984   htab = ppc_hash_table (info);
12985   if (htab == NULL)
12986     return FALSE;
12987
12988   s = htab->glink;
12989   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12990     if (pent->plt.offset != (bfd_vma) -1
12991         && pent->addend == 0)
12992       {
12993         bfd_byte *p;
12994         asection *plt;
12995         bfd_vma off;
12996
12997         p = s->contents + h->root.u.def.value;
12998         plt = htab->elf.splt;
12999         if (!htab->elf.dynamic_sections_created
13000             || h->dynindx == -1)
13001           plt = htab->elf.iplt;
13002         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13003         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13004
13005         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13006           {
13007             info->callbacks->einfo
13008               (_("%P: linkage table error against `%T'\n"),
13009                h->root.root.string);
13010             bfd_set_error (bfd_error_bad_value);
13011             htab->stub_error = TRUE;
13012           }
13013
13014         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13015         if (htab->params->emit_stub_syms)
13016           {
13017             size_t len = strlen (h->root.root.string);
13018             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13019
13020             if (name == NULL)
13021               return FALSE;
13022
13023             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13024             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13025             if (h == NULL)
13026               return FALSE;
13027             if (h->root.type == bfd_link_hash_new)
13028               {
13029                 h->root.type = bfd_link_hash_defined;
13030                 h->root.u.def.section = s;
13031                 h->root.u.def.value = p - s->contents;
13032                 h->ref_regular = 1;
13033                 h->def_regular = 1;
13034                 h->ref_regular_nonweak = 1;
13035                 h->forced_local = 1;
13036                 h->non_elf = 0;
13037                 h->root.linker_def = 1;
13038               }
13039           }
13040
13041         if (PPC_HA (off) != 0)
13042           {
13043             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13044             p += 4;
13045           }
13046         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13047         p += 4;
13048         bfd_put_32 (s->owner, MTCTR_R12, p);
13049         p += 4;
13050         bfd_put_32 (s->owner, BCTR, p);
13051         break;
13052       }
13053   return TRUE;
13054 }
13055
13056 /* Build all the stubs associated with the current output file.
13057    The stubs are kept in a hash table attached to the main linker
13058    hash table.  This function is called via gldelf64ppc_finish.  */
13059
13060 bfd_boolean
13061 ppc64_elf_build_stubs (struct bfd_link_info *info,
13062                        char **stats)
13063 {
13064   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13065   struct map_stub *group;
13066   asection *stub_sec;
13067   bfd_byte *p;
13068   int stub_sec_count = 0;
13069
13070   if (htab == NULL)
13071     return FALSE;
13072
13073   /* Allocate memory to hold the linker stubs.  */
13074   for (stub_sec = htab->params->stub_bfd->sections;
13075        stub_sec != NULL;
13076        stub_sec = stub_sec->next)
13077     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13078         && stub_sec->size != 0)
13079       {
13080         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13081         if (stub_sec->contents == NULL)
13082           return FALSE;
13083         stub_sec->size = 0;
13084       }
13085
13086   if (htab->glink != NULL && htab->glink->size != 0)
13087     {
13088       unsigned int indx;
13089       bfd_vma plt0;
13090
13091       /* Build the .glink plt call stub.  */
13092       if (htab->params->emit_stub_syms)
13093         {
13094           struct elf_link_hash_entry *h;
13095           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13096                                     TRUE, FALSE, FALSE);
13097           if (h == NULL)
13098             return FALSE;
13099           if (h->root.type == bfd_link_hash_new)
13100             {
13101               h->root.type = bfd_link_hash_defined;
13102               h->root.u.def.section = htab->glink;
13103               h->root.u.def.value = 8;
13104               h->ref_regular = 1;
13105               h->def_regular = 1;
13106               h->ref_regular_nonweak = 1;
13107               h->forced_local = 1;
13108               h->non_elf = 0;
13109               h->root.linker_def = 1;
13110             }
13111         }
13112       plt0 = (htab->elf.splt->output_section->vma
13113               + htab->elf.splt->output_offset
13114               - 16);
13115       if (info->emitrelocations)
13116         {
13117           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13118           if (r == NULL)
13119             return FALSE;
13120           r->r_offset = (htab->glink->output_offset
13121                          + htab->glink->output_section->vma);
13122           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13123           r->r_addend = plt0;
13124         }
13125       p = htab->glink->contents;
13126       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13127       bfd_put_64 (htab->glink->owner, plt0, p);
13128       p += 8;
13129       if (htab->opd_abi)
13130         {
13131           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13132           p += 4;
13133           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13134           p += 4;
13135           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13136           p += 4;
13137           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13138           p += 4;
13139           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13140           p += 4;
13141           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13142           p += 4;
13143           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13144           p += 4;
13145           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13146           p += 4;
13147           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13148           p += 4;
13149           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13150           p += 4;
13151         }
13152       else
13153         {
13154           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13155           p += 4;
13156           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13157           p += 4;
13158           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13159           p += 4;
13160           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13161           p += 4;
13162           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13163           p += 4;
13164           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13165           p += 4;
13166           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13167           p += 4;
13168           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13169           p += 4;
13170           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13171           p += 4;
13172           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13173           p += 4;
13174           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13175           p += 4;
13176           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13177           p += 4;
13178         }
13179       bfd_put_32 (htab->glink->owner, BCTR, p);
13180       p += 4;
13181       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13182         {
13183           bfd_put_32 (htab->glink->owner, NOP, p);
13184           p += 4;
13185         }
13186
13187       /* Build the .glink lazy link call stubs.  */
13188       indx = 0;
13189       while (p < htab->glink->contents + htab->glink->rawsize)
13190         {
13191           if (htab->opd_abi)
13192             {
13193               if (indx < 0x8000)
13194                 {
13195                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13196                   p += 4;
13197                 }
13198               else
13199                 {
13200                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13201                   p += 4;
13202                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13203                               p);
13204                   p += 4;
13205                 }
13206             }
13207           bfd_put_32 (htab->glink->owner,
13208                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13209           indx++;
13210           p += 4;
13211         }
13212
13213       /* Build .glink global entry stubs.  */
13214       if (htab->glink->size > htab->glink->rawsize)
13215         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13216     }
13217
13218   if (htab->brlt != NULL && htab->brlt->size != 0)
13219     {
13220       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13221                                          htab->brlt->size);
13222       if (htab->brlt->contents == NULL)
13223         return FALSE;
13224     }
13225   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13226     {
13227       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13228                                             htab->relbrlt->size);
13229       if (htab->relbrlt->contents == NULL)
13230         return FALSE;
13231     }
13232
13233   /* Build the stubs as directed by the stub hash table.  */
13234   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13235
13236   for (group = htab->group; group != NULL; group = group->next)
13237     if (group->needs_save_res)
13238       {
13239         stub_sec = group->stub_sec;
13240         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13241                 htab->sfpr->size);
13242         if (htab->params->emit_stub_syms)
13243           {
13244             unsigned int i;
13245
13246             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13247               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13248                 return FALSE;
13249           }
13250         stub_sec->size += htab->sfpr->size;
13251       }
13252
13253   if (htab->relbrlt != NULL)
13254     htab->relbrlt->reloc_count = 0;
13255
13256   if (htab->params->plt_stub_align != 0)
13257     for (stub_sec = htab->params->stub_bfd->sections;
13258          stub_sec != NULL;
13259          stub_sec = stub_sec->next)
13260       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13261         stub_sec->size = ((stub_sec->size
13262                            + (1 << htab->params->plt_stub_align) - 1)
13263                           & -(1 << htab->params->plt_stub_align));
13264
13265   for (stub_sec = htab->params->stub_bfd->sections;
13266        stub_sec != NULL;
13267        stub_sec = stub_sec->next)
13268     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13269       {
13270         stub_sec_count += 1;
13271         if (stub_sec->rawsize != stub_sec->size
13272             && (htab->stub_iteration <= STUB_SHRINK_ITER
13273                 || stub_sec->rawsize < stub_sec->size))
13274           break;
13275       }
13276
13277   /* Note that the glink_eh_frame check here is not only testing that
13278      the generated size matched the calculated size but also that
13279      bfd_elf_discard_info didn't make any changes to the section.  */
13280   if (stub_sec != NULL
13281       || (htab->glink_eh_frame != NULL
13282           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13283     {
13284       htab->stub_error = TRUE;
13285       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13286     }
13287
13288   if (htab->stub_error)
13289     return FALSE;
13290
13291   if (stats != NULL)
13292     {
13293       *stats = bfd_malloc (500);
13294       if (*stats == NULL)
13295         return FALSE;
13296
13297       sprintf (*stats, _("linker stubs in %u group%s\n"
13298                          "  branch       %lu\n"
13299                          "  toc adjust   %lu\n"
13300                          "  long branch  %lu\n"
13301                          "  long toc adj %lu\n"
13302                          "  plt call     %lu\n"
13303                          "  plt call toc %lu\n"
13304                          "  global entry %lu"),
13305                stub_sec_count,
13306                stub_sec_count == 1 ? "" : "s",
13307                htab->stub_count[ppc_stub_long_branch - 1],
13308                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13309                htab->stub_count[ppc_stub_plt_branch - 1],
13310                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13311                htab->stub_count[ppc_stub_plt_call - 1],
13312                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13313                htab->stub_count[ppc_stub_global_entry - 1]);
13314     }
13315   return TRUE;
13316 }
13317
13318 /* What to do when ld finds relocations against symbols defined in
13319    discarded sections.  */
13320
13321 static unsigned int
13322 ppc64_elf_action_discarded (asection *sec)
13323 {
13324   if (strcmp (".opd", sec->name) == 0)
13325     return 0;
13326
13327   if (strcmp (".toc", sec->name) == 0)
13328     return 0;
13329
13330   if (strcmp (".toc1", sec->name) == 0)
13331     return 0;
13332
13333   return _bfd_elf_default_action_discarded (sec);
13334 }
13335
13336 /* The RELOCATE_SECTION function is called by the ELF backend linker
13337    to handle the relocations for a section.
13338
13339    The relocs are always passed as Rela structures; if the section
13340    actually uses Rel structures, the r_addend field will always be
13341    zero.
13342
13343    This function is responsible for adjust the section contents as
13344    necessary, and (if using Rela relocs and generating a
13345    relocatable output file) adjusting the reloc addend as
13346    necessary.
13347
13348    This function does not have to worry about setting the reloc
13349    address or the reloc symbol index.
13350
13351    LOCAL_SYMS is a pointer to the swapped in local symbols.
13352
13353    LOCAL_SECTIONS is an array giving the section in the input file
13354    corresponding to the st_shndx field of each local symbol.
13355
13356    The global hash table entry for the global symbols can be found
13357    via elf_sym_hashes (input_bfd).
13358
13359    When generating relocatable output, this function must handle
13360    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13361    going to be the section symbol corresponding to the output
13362    section, which means that the addend must be adjusted
13363    accordingly.  */
13364
13365 static bfd_boolean
13366 ppc64_elf_relocate_section (bfd *output_bfd,
13367                             struct bfd_link_info *info,
13368                             bfd *input_bfd,
13369                             asection *input_section,
13370                             bfd_byte *contents,
13371                             Elf_Internal_Rela *relocs,
13372                             Elf_Internal_Sym *local_syms,
13373                             asection **local_sections)
13374 {
13375   struct ppc_link_hash_table *htab;
13376   Elf_Internal_Shdr *symtab_hdr;
13377   struct elf_link_hash_entry **sym_hashes;
13378   Elf_Internal_Rela *rel;
13379   Elf_Internal_Rela *wrel;
13380   Elf_Internal_Rela *relend;
13381   Elf_Internal_Rela outrel;
13382   bfd_byte *loc;
13383   struct got_entry **local_got_ents;
13384   bfd_vma TOCstart;
13385   bfd_boolean ret = TRUE;
13386   bfd_boolean is_opd;
13387   /* Assume 'at' branch hints.  */
13388   bfd_boolean is_isa_v2 = TRUE;
13389   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13390
13391   /* Initialize howto table if needed.  */
13392   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13393     ppc_howto_init ();
13394
13395   htab = ppc_hash_table (info);
13396   if (htab == NULL)
13397     return FALSE;
13398
13399   /* Don't relocate stub sections.  */
13400   if (input_section->owner == htab->params->stub_bfd)
13401     return TRUE;
13402
13403   BFD_ASSERT (is_ppc64_elf (input_bfd));
13404
13405   local_got_ents = elf_local_got_ents (input_bfd);
13406   TOCstart = elf_gp (output_bfd);
13407   symtab_hdr = &elf_symtab_hdr (input_bfd);
13408   sym_hashes = elf_sym_hashes (input_bfd);
13409   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13410
13411   rel = wrel = relocs;
13412   relend = relocs + input_section->reloc_count;
13413   for (; rel < relend; wrel++, rel++)
13414     {
13415       enum elf_ppc64_reloc_type r_type;
13416       bfd_vma addend;
13417       bfd_reloc_status_type r;
13418       Elf_Internal_Sym *sym;
13419       asection *sec;
13420       struct elf_link_hash_entry *h_elf;
13421       struct ppc_link_hash_entry *h;
13422       struct ppc_link_hash_entry *fdh;
13423       const char *sym_name;
13424       unsigned long r_symndx, toc_symndx;
13425       bfd_vma toc_addend;
13426       unsigned char tls_mask, tls_gd, tls_type;
13427       unsigned char sym_type;
13428       bfd_vma relocation;
13429       bfd_boolean unresolved_reloc;
13430       bfd_boolean warned;
13431       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13432       unsigned int insn;
13433       unsigned int mask;
13434       struct ppc_stub_hash_entry *stub_entry;
13435       bfd_vma max_br_offset;
13436       bfd_vma from;
13437       Elf_Internal_Rela orig_rel;
13438       reloc_howto_type *howto;
13439       struct reloc_howto_struct alt_howto;
13440
13441     again:
13442       orig_rel = *rel;
13443
13444       r_type = ELF64_R_TYPE (rel->r_info);
13445       r_symndx = ELF64_R_SYM (rel->r_info);
13446
13447       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13448          symbol of the previous ADDR64 reloc.  The symbol gives us the
13449          proper TOC base to use.  */
13450       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13451           && wrel != relocs
13452           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13453           && is_opd)
13454         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13455
13456       sym = NULL;
13457       sec = NULL;
13458       h_elf = NULL;
13459       sym_name = NULL;
13460       unresolved_reloc = FALSE;
13461       warned = FALSE;
13462
13463       if (r_symndx < symtab_hdr->sh_info)
13464         {
13465           /* It's a local symbol.  */
13466           struct _opd_sec_data *opd;
13467
13468           sym = local_syms + r_symndx;
13469           sec = local_sections[r_symndx];
13470           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13471           sym_type = ELF64_ST_TYPE (sym->st_info);
13472           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13473           opd = get_opd_info (sec);
13474           if (opd != NULL && opd->adjust != NULL)
13475             {
13476               long adjust = opd->adjust[OPD_NDX (sym->st_value
13477                                                  + rel->r_addend)];
13478               if (adjust == -1)
13479                 relocation = 0;
13480               else
13481                 {
13482                   /* If this is a relocation against the opd section sym
13483                      and we have edited .opd, adjust the reloc addend so
13484                      that ld -r and ld --emit-relocs output is correct.
13485                      If it is a reloc against some other .opd symbol,
13486                      then the symbol value will be adjusted later.  */
13487                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13488                     rel->r_addend += adjust;
13489                   else
13490                     relocation += adjust;
13491                 }
13492             }
13493         }
13494       else
13495         {
13496           bfd_boolean ignored;
13497
13498           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13499                                    r_symndx, symtab_hdr, sym_hashes,
13500                                    h_elf, sec, relocation,
13501                                    unresolved_reloc, warned, ignored);
13502           sym_name = h_elf->root.root.string;
13503           sym_type = h_elf->type;
13504           if (sec != NULL
13505               && sec->owner == output_bfd
13506               && strcmp (sec->name, ".opd") == 0)
13507             {
13508               /* This is a symbol defined in a linker script.  All
13509                  such are defined in output sections, even those
13510                  defined by simple assignment from a symbol defined in
13511                  an input section.  Transfer the symbol to an
13512                  appropriate input .opd section, so that a branch to
13513                  this symbol will be mapped to the location specified
13514                  by the opd entry.  */
13515               struct bfd_link_order *lo;
13516               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13517                 if (lo->type == bfd_indirect_link_order)
13518                   {
13519                     asection *isec = lo->u.indirect.section;
13520                     if (h_elf->root.u.def.value >= isec->output_offset
13521                         && h_elf->root.u.def.value < (isec->output_offset
13522                                                       + isec->size))
13523                       {
13524                         h_elf->root.u.def.value -= isec->output_offset;
13525                         h_elf->root.u.def.section = isec;
13526                         sec = isec;
13527                         break;
13528                       }
13529                   }
13530             }
13531         }
13532       h = (struct ppc_link_hash_entry *) h_elf;
13533
13534       if (sec != NULL && discarded_section (sec))
13535         {
13536           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13537                                input_bfd, input_section,
13538                                contents + rel->r_offset);
13539           wrel->r_offset = rel->r_offset;
13540           wrel->r_info = 0;
13541           wrel->r_addend = 0;
13542
13543           /* For ld -r, remove relocations in debug sections against
13544              sections defined in discarded sections.  Not done for
13545              non-debug to preserve relocs in .eh_frame which the
13546              eh_frame editing code expects to be present.  */
13547           if (bfd_link_relocatable (info)
13548               && (input_section->flags & SEC_DEBUGGING))
13549             wrel--;
13550
13551           continue;
13552         }
13553
13554       if (bfd_link_relocatable (info))
13555         goto copy_reloc;
13556
13557       if (h != NULL && &h->elf == htab->elf.hgot)
13558         {
13559           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13560           sec = bfd_abs_section_ptr;
13561           unresolved_reloc = FALSE;
13562         }
13563
13564       /* TLS optimizations.  Replace instruction sequences and relocs
13565          based on information we collected in tls_optimize.  We edit
13566          RELOCS so that --emit-relocs will output something sensible
13567          for the final instruction stream.  */
13568       tls_mask = 0;
13569       tls_gd = 0;
13570       toc_symndx = 0;
13571       if (h != NULL)
13572         tls_mask = h->tls_mask;
13573       else if (local_got_ents != NULL)
13574         {
13575           struct plt_entry **local_plt = (struct plt_entry **)
13576             (local_got_ents + symtab_hdr->sh_info);
13577           unsigned char *lgot_masks = (unsigned char *)
13578             (local_plt + symtab_hdr->sh_info);
13579           tls_mask = lgot_masks[r_symndx];
13580         }
13581       if (tls_mask == 0
13582           && (r_type == R_PPC64_TLS
13583               || r_type == R_PPC64_TLSGD
13584               || r_type == R_PPC64_TLSLD))
13585         {
13586           /* Check for toc tls entries.  */
13587           unsigned char *toc_tls;
13588
13589           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13590                              &local_syms, rel, input_bfd))
13591             return FALSE;
13592
13593           if (toc_tls)
13594             tls_mask = *toc_tls;
13595         }
13596
13597       /* Check that tls relocs are used with tls syms, and non-tls
13598          relocs are used with non-tls syms.  */
13599       if (r_symndx != STN_UNDEF
13600           && r_type != R_PPC64_NONE
13601           && (h == NULL
13602               || h->elf.root.type == bfd_link_hash_defined
13603               || h->elf.root.type == bfd_link_hash_defweak)
13604           && (IS_PPC64_TLS_RELOC (r_type)
13605               != (sym_type == STT_TLS
13606                   || (sym_type == STT_SECTION
13607                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13608         {
13609           if (tls_mask != 0
13610               && (r_type == R_PPC64_TLS
13611                   || r_type == R_PPC64_TLSGD
13612                   || r_type == R_PPC64_TLSLD))
13613             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13614             ;
13615           else
13616             info->callbacks->einfo
13617               (!IS_PPC64_TLS_RELOC (r_type)
13618                /* xgettext:c-format */
13619                ? _("%H: %s used with TLS symbol `%T'\n")
13620                /* xgettext:c-format */
13621                : _("%H: %s used with non-TLS symbol `%T'\n"),
13622                input_bfd, input_section, rel->r_offset,
13623                ppc64_elf_howto_table[r_type]->name,
13624                sym_name);
13625         }
13626
13627       /* Ensure reloc mapping code below stays sane.  */
13628       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13629           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13630           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13631           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13632           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13633           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13634           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13635           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13636           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13637           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13638         abort ();
13639
13640       switch (r_type)
13641         {
13642         default:
13643           break;
13644
13645         case R_PPC64_LO_DS_OPT:
13646           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13647           if ((insn & (0x3f << 26)) != 58u << 26)
13648             abort ();
13649           insn += (14u << 26) - (58u << 26);
13650           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13651           r_type = R_PPC64_TOC16_LO;
13652           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13653           break;
13654
13655         case R_PPC64_TOC16:
13656         case R_PPC64_TOC16_LO:
13657         case R_PPC64_TOC16_DS:
13658         case R_PPC64_TOC16_LO_DS:
13659           {
13660             /* Check for toc tls entries.  */
13661             unsigned char *toc_tls;
13662             int retval;
13663
13664             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13665                                    &local_syms, rel, input_bfd);
13666             if (retval == 0)
13667               return FALSE;
13668
13669             if (toc_tls)
13670               {
13671                 tls_mask = *toc_tls;
13672                 if (r_type == R_PPC64_TOC16_DS
13673                     || r_type == R_PPC64_TOC16_LO_DS)
13674                   {
13675                     if (tls_mask != 0
13676                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13677                       goto toctprel;
13678                   }
13679                 else
13680                   {
13681                     /* If we found a GD reloc pair, then we might be
13682                        doing a GD->IE transition.  */
13683                     if (retval == 2)
13684                       {
13685                         tls_gd = TLS_TPRELGD;
13686                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13687                           goto tls_ldgd_opt;
13688                       }
13689                     else if (retval == 3)
13690                       {
13691                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13692                           goto tls_ldgd_opt;
13693                       }
13694                   }
13695               }
13696           }
13697           break;
13698
13699         case R_PPC64_GOT_TPREL16_HI:
13700         case R_PPC64_GOT_TPREL16_HA:
13701           if (tls_mask != 0
13702               && (tls_mask & TLS_TPREL) == 0)
13703             {
13704               rel->r_offset -= d_offset;
13705               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13706               r_type = R_PPC64_NONE;
13707               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13708             }
13709           break;
13710
13711         case R_PPC64_GOT_TPREL16_DS:
13712         case R_PPC64_GOT_TPREL16_LO_DS:
13713           if (tls_mask != 0
13714               && (tls_mask & TLS_TPREL) == 0)
13715             {
13716             toctprel:
13717               insn = bfd_get_32 (input_bfd,
13718                                  contents + rel->r_offset - d_offset);
13719               insn &= 31 << 21;
13720               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13721               bfd_put_32 (input_bfd, insn,
13722                           contents + rel->r_offset - d_offset);
13723               r_type = R_PPC64_TPREL16_HA;
13724               if (toc_symndx != 0)
13725                 {
13726                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13727                   rel->r_addend = toc_addend;
13728                   /* We changed the symbol.  Start over in order to
13729                      get h, sym, sec etc. right.  */
13730                   goto again;
13731                 }
13732               else
13733                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13734             }
13735           break;
13736
13737         case R_PPC64_TLS:
13738           if (tls_mask != 0
13739               && (tls_mask & TLS_TPREL) == 0)
13740             {
13741               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13742               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13743               if (insn == 0)
13744                 abort ();
13745               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13746               /* Was PPC64_TLS which sits on insn boundary, now
13747                  PPC64_TPREL16_LO which is at low-order half-word.  */
13748               rel->r_offset += d_offset;
13749               r_type = R_PPC64_TPREL16_LO;
13750               if (toc_symndx != 0)
13751                 {
13752                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13753                   rel->r_addend = toc_addend;
13754                   /* We changed the symbol.  Start over in order to
13755                      get h, sym, sec etc. right.  */
13756                   goto again;
13757                 }
13758               else
13759                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13760             }
13761           break;
13762
13763         case R_PPC64_GOT_TLSGD16_HI:
13764         case R_PPC64_GOT_TLSGD16_HA:
13765           tls_gd = TLS_TPRELGD;
13766           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13767             goto tls_gdld_hi;
13768           break;
13769
13770         case R_PPC64_GOT_TLSLD16_HI:
13771         case R_PPC64_GOT_TLSLD16_HA:
13772           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13773             {
13774             tls_gdld_hi:
13775               if ((tls_mask & tls_gd) != 0)
13776                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13777                           + R_PPC64_GOT_TPREL16_DS);
13778               else
13779                 {
13780                   rel->r_offset -= d_offset;
13781                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13782                   r_type = R_PPC64_NONE;
13783                 }
13784               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13785             }
13786           break;
13787
13788         case R_PPC64_GOT_TLSGD16:
13789         case R_PPC64_GOT_TLSGD16_LO:
13790           tls_gd = TLS_TPRELGD;
13791           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13792             goto tls_ldgd_opt;
13793           break;
13794
13795         case R_PPC64_GOT_TLSLD16:
13796         case R_PPC64_GOT_TLSLD16_LO:
13797           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13798             {
13799               unsigned int insn1, insn2, insn3;
13800               bfd_vma offset;
13801
13802             tls_ldgd_opt:
13803               offset = (bfd_vma) -1;
13804               /* If not using the newer R_PPC64_TLSGD/LD to mark
13805                  __tls_get_addr calls, we must trust that the call
13806                  stays with its arg setup insns, ie. that the next
13807                  reloc is the __tls_get_addr call associated with
13808                  the current reloc.  Edit both insns.  */
13809               if (input_section->has_tls_get_addr_call
13810                   && rel + 1 < relend
13811                   && branch_reloc_hash_match (input_bfd, rel + 1,
13812                                               htab->tls_get_addr,
13813                                               htab->tls_get_addr_fd))
13814                 offset = rel[1].r_offset;
13815               /* We read the low GOT_TLS (or TOC16) insn because we
13816                  need to keep the destination reg.  It may be
13817                  something other than the usual r3, and moved to r3
13818                  before the call by intervening code.  */
13819               insn1 = bfd_get_32 (input_bfd,
13820                                   contents + rel->r_offset - d_offset);
13821               if ((tls_mask & tls_gd) != 0)
13822                 {
13823                   /* IE */
13824                   insn1 &= (0x1f << 21) | (0x1f << 16);
13825                   insn1 |= 58 << 26;    /* ld */
13826                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13827                   if (offset != (bfd_vma) -1)
13828                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13829                   if ((tls_mask & TLS_EXPLICIT) == 0)
13830                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13831                               + R_PPC64_GOT_TPREL16_DS);
13832                   else
13833                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13834                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13835                 }
13836               else
13837                 {
13838                   /* LE */
13839                   insn1 &= 0x1f << 21;
13840                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13841                   insn2 = 0x38630000;   /* addi 3,3,0 */
13842                   if (tls_gd == 0)
13843                     {
13844                       /* Was an LD reloc.  */
13845                       if (toc_symndx)
13846                         sec = local_sections[toc_symndx];
13847                       for (r_symndx = 0;
13848                            r_symndx < symtab_hdr->sh_info;
13849                            r_symndx++)
13850                         if (local_sections[r_symndx] == sec)
13851                           break;
13852                       if (r_symndx >= symtab_hdr->sh_info)
13853                         r_symndx = STN_UNDEF;
13854                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13855                       if (r_symndx != STN_UNDEF)
13856                         rel->r_addend -= (local_syms[r_symndx].st_value
13857                                           + sec->output_offset
13858                                           + sec->output_section->vma);
13859                     }
13860                   else if (toc_symndx != 0)
13861                     {
13862                       r_symndx = toc_symndx;
13863                       rel->r_addend = toc_addend;
13864                     }
13865                   r_type = R_PPC64_TPREL16_HA;
13866                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13867                   if (offset != (bfd_vma) -1)
13868                     {
13869                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13870                                                     R_PPC64_TPREL16_LO);
13871                       rel[1].r_offset = offset + d_offset;
13872                       rel[1].r_addend = rel->r_addend;
13873                     }
13874                 }
13875               bfd_put_32 (input_bfd, insn1,
13876                           contents + rel->r_offset - d_offset);
13877               if (offset != (bfd_vma) -1)
13878                 {
13879                   insn3 = bfd_get_32 (input_bfd,
13880                                       contents + offset + 4);
13881                   if (insn3 == NOP
13882                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13883                     {
13884                       rel[1].r_offset += 4;
13885                       bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13886                       insn2 = NOP;
13887                     }
13888                   bfd_put_32 (input_bfd, insn2, contents + offset);
13889                 }
13890               if ((tls_mask & tls_gd) == 0
13891                   && (tls_gd == 0 || toc_symndx != 0))
13892                 {
13893                   /* We changed the symbol.  Start over in order
13894                      to get h, sym, sec etc. right.  */
13895                   goto again;
13896                 }
13897             }
13898           break;
13899
13900         case R_PPC64_TLSGD:
13901           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13902             {
13903               unsigned int insn2, insn3;
13904               bfd_vma offset = rel->r_offset;
13905
13906               if ((tls_mask & TLS_TPRELGD) != 0)
13907                 {
13908                   /* IE */
13909                   r_type = R_PPC64_NONE;
13910                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13911                 }
13912               else
13913                 {
13914                   /* LE */
13915                   if (toc_symndx != 0)
13916                     {
13917                       r_symndx = toc_symndx;
13918                       rel->r_addend = toc_addend;
13919                     }
13920                   r_type = R_PPC64_TPREL16_LO;
13921                   rel->r_offset = offset + d_offset;
13922                   insn2 = 0x38630000;   /* addi 3,3,0 */
13923                 }
13924               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13925               /* Zap the reloc on the _tls_get_addr call too.  */
13926               BFD_ASSERT (offset == rel[1].r_offset);
13927               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13928               insn3 = bfd_get_32 (input_bfd,
13929                                   contents + offset + 4);
13930               if (insn3 == NOP
13931                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13932                 {
13933                   rel->r_offset += 4;
13934                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13935                   insn2 = NOP;
13936                 }
13937               bfd_put_32 (input_bfd, insn2, contents + offset);
13938               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13939                 goto again;
13940             }
13941           break;
13942
13943         case R_PPC64_TLSLD:
13944           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13945             {
13946               unsigned int insn2, insn3;
13947               bfd_vma offset = rel->r_offset;
13948
13949               if (toc_symndx)
13950                 sec = local_sections[toc_symndx];
13951               for (r_symndx = 0;
13952                    r_symndx < symtab_hdr->sh_info;
13953                    r_symndx++)
13954                 if (local_sections[r_symndx] == sec)
13955                   break;
13956               if (r_symndx >= symtab_hdr->sh_info)
13957                 r_symndx = STN_UNDEF;
13958               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13959               if (r_symndx != STN_UNDEF)
13960                 rel->r_addend -= (local_syms[r_symndx].st_value
13961                                   + sec->output_offset
13962                                   + sec->output_section->vma);
13963
13964               r_type = R_PPC64_TPREL16_LO;
13965               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13966               rel->r_offset = offset + d_offset;
13967               /* Zap the reloc on the _tls_get_addr call too.  */
13968               BFD_ASSERT (offset == rel[1].r_offset);
13969               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13970               insn2 = 0x38630000;       /* addi 3,3,0 */
13971               insn3 = bfd_get_32 (input_bfd,
13972                                   contents + offset + 4);
13973               if (insn3 == NOP
13974                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13975                 {
13976                   rel->r_offset += 4;
13977                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13978                   insn2 = NOP;
13979                 }
13980               bfd_put_32 (input_bfd, insn2, contents + offset);
13981               goto again;
13982             }
13983           break;
13984
13985         case R_PPC64_DTPMOD64:
13986           if (rel + 1 < relend
13987               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13988               && rel[1].r_offset == rel->r_offset + 8)
13989             {
13990               if ((tls_mask & TLS_GD) == 0)
13991                 {
13992                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13993                   if ((tls_mask & TLS_TPRELGD) != 0)
13994                     r_type = R_PPC64_TPREL64;
13995                   else
13996                     {
13997                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13998                       r_type = R_PPC64_NONE;
13999                     }
14000                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14001                 }
14002             }
14003           else
14004             {
14005               if ((tls_mask & TLS_LD) == 0)
14006                 {
14007                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14008                   r_type = R_PPC64_NONE;
14009                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14010                 }
14011             }
14012           break;
14013
14014         case R_PPC64_TPREL64:
14015           if ((tls_mask & TLS_TPREL) == 0)
14016             {
14017               r_type = R_PPC64_NONE;
14018               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14019             }
14020           break;
14021
14022         case R_PPC64_ENTRY:
14023           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14024           if (!bfd_link_pic (info)
14025               && !info->traditional_format
14026               && relocation + 0x80008000 <= 0xffffffff)
14027             {
14028               unsigned int insn1, insn2;
14029
14030               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14031               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14032               if ((insn1 & ~0xfffc) == LD_R2_0R12
14033                   && insn2 == ADD_R2_R2_R12)
14034                 {
14035                   bfd_put_32 (input_bfd,
14036                               LIS_R2 + PPC_HA (relocation),
14037                               contents + rel->r_offset);
14038                   bfd_put_32 (input_bfd,
14039                               ADDI_R2_R2 + PPC_LO (relocation),
14040                               contents + rel->r_offset + 4);
14041                 }
14042             }
14043           else
14044             {
14045               relocation -= (rel->r_offset
14046                              + input_section->output_offset
14047                              + input_section->output_section->vma);
14048               if (relocation + 0x80008000 <= 0xffffffff)
14049                 {
14050                   unsigned int insn1, insn2;
14051
14052                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14053                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14054                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14055                       && insn2 == ADD_R2_R2_R12)
14056                     {
14057                       bfd_put_32 (input_bfd,
14058                                   ADDIS_R2_R12 + PPC_HA (relocation),
14059                                   contents + rel->r_offset);
14060                       bfd_put_32 (input_bfd,
14061                                   ADDI_R2_R2 + PPC_LO (relocation),
14062                                   contents + rel->r_offset + 4);
14063                     }
14064                 }
14065             }
14066           break;
14067
14068         case R_PPC64_REL16_HA:
14069           /* If we are generating a non-PIC executable, edit
14070              .  0:      addis 2,12,.TOC.-0b@ha
14071              .          addi 2,2,.TOC.-0b@l
14072              used by ELFv2 global entry points to set up r2, to
14073              .          lis 2,.TOC.@ha
14074              .          addi 2,2,.TOC.@l
14075              if .TOC. is in range.  */
14076           if (!bfd_link_pic (info)
14077               && !info->traditional_format
14078               && !htab->opd_abi
14079               && rel->r_addend == d_offset
14080               && h != NULL && &h->elf == htab->elf.hgot
14081               && rel + 1 < relend
14082               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14083               && rel[1].r_offset == rel->r_offset + 4
14084               && rel[1].r_addend == rel->r_addend + 4
14085               && relocation + 0x80008000 <= 0xffffffff)
14086             {
14087               unsigned int insn1, insn2;
14088               bfd_vma offset = rel->r_offset - d_offset;
14089               insn1 = bfd_get_32 (input_bfd, contents + offset);
14090               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14091               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14092                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14093                 {
14094                   r_type = R_PPC64_ADDR16_HA;
14095                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14096                   rel->r_addend -= d_offset;
14097                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14098                   rel[1].r_addend -= d_offset + 4;
14099                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14100                 }
14101             }
14102           break;
14103         }
14104
14105       /* Handle other relocations that tweak non-addend part of insn.  */
14106       insn = 0;
14107       max_br_offset = 1 << 25;
14108       addend = rel->r_addend;
14109       reloc_dest = DEST_NORMAL;
14110       switch (r_type)
14111         {
14112         default:
14113           break;
14114
14115         case R_PPC64_TOCSAVE:
14116           if (relocation + addend == (rel->r_offset
14117                                       + input_section->output_offset
14118                                       + input_section->output_section->vma)
14119               && tocsave_find (htab, NO_INSERT,
14120                                &local_syms, rel, input_bfd))
14121             {
14122               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14123               if (insn == NOP
14124                   || insn == CROR_151515 || insn == CROR_313131)
14125                 bfd_put_32 (input_bfd,
14126                             STD_R2_0R1 + STK_TOC (htab),
14127                             contents + rel->r_offset);
14128             }
14129           break;
14130
14131           /* Branch taken prediction relocations.  */
14132         case R_PPC64_ADDR14_BRTAKEN:
14133         case R_PPC64_REL14_BRTAKEN:
14134           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14135           /* Fall through.  */
14136
14137           /* Branch not taken prediction relocations.  */
14138         case R_PPC64_ADDR14_BRNTAKEN:
14139         case R_PPC64_REL14_BRNTAKEN:
14140           insn |= bfd_get_32 (input_bfd,
14141                               contents + rel->r_offset) & ~(0x01 << 21);
14142           /* Fall through.  */
14143
14144         case R_PPC64_REL14:
14145           max_br_offset = 1 << 15;
14146           /* Fall through.  */
14147
14148         case R_PPC64_REL24:
14149           /* Calls to functions with a different TOC, such as calls to
14150              shared objects, need to alter the TOC pointer.  This is
14151              done using a linkage stub.  A REL24 branching to these
14152              linkage stubs needs to be followed by a nop, as the nop
14153              will be replaced with an instruction to restore the TOC
14154              base pointer.  */
14155           fdh = h;
14156           if (h != NULL
14157               && h->oh != NULL
14158               && h->oh->is_func_descriptor)
14159             fdh = ppc_follow_link (h->oh);
14160           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14161                                            htab);
14162           if (stub_entry != NULL
14163               && (stub_entry->stub_type == ppc_stub_plt_call
14164                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14165                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14166                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14167             {
14168               bfd_boolean can_plt_call = FALSE;
14169
14170               /* All of these stubs will modify r2, so there must be a
14171                  branch and link followed by a nop.  The nop is
14172                  replaced by an insn to restore r2.  */
14173               if (rel->r_offset + 8 <= input_section->size)
14174                 {
14175                   unsigned long br;
14176
14177                   br = bfd_get_32 (input_bfd,
14178                                    contents + rel->r_offset);
14179                   if ((br & 1) != 0)
14180                     {
14181                       unsigned long nop;
14182
14183                       nop = bfd_get_32 (input_bfd,
14184                                         contents + rel->r_offset + 4);
14185                       if (nop == NOP
14186                           || nop == CROR_151515 || nop == CROR_313131)
14187                         {
14188                           if (h != NULL
14189                               && (h == htab->tls_get_addr_fd
14190                                   || h == htab->tls_get_addr)
14191                               && htab->params->tls_get_addr_opt)
14192                             {
14193                               /* Special stub used, leave nop alone.  */
14194                             }
14195                           else
14196                             bfd_put_32 (input_bfd,
14197                                         LD_R2_0R1 + STK_TOC (htab),
14198                                         contents + rel->r_offset + 4);
14199                           can_plt_call = TRUE;
14200                         }
14201                     }
14202                 }
14203
14204               if (!can_plt_call && h != NULL)
14205                 {
14206                   const char *name = h->elf.root.root.string;
14207
14208                   if (*name == '.')
14209                     ++name;
14210
14211                   if (strncmp (name, "__libc_start_main", 17) == 0
14212                       && (name[17] == 0 || name[17] == '@'))
14213                     {
14214                       /* Allow crt1 branch to go via a toc adjusting
14215                          stub.  Other calls that never return could do
14216                          the same, if we could detect such.  */
14217                       can_plt_call = TRUE;
14218                     }
14219                 }
14220
14221               if (!can_plt_call)
14222                 {
14223                   /* g++ as of 20130507 emits self-calls without a
14224                      following nop.  This is arguably wrong since we
14225                      have conflicting information.  On the one hand a
14226                      global symbol and on the other a local call
14227                      sequence, but don't error for this special case.
14228                      It isn't possible to cheaply verify we have
14229                      exactly such a call.  Allow all calls to the same
14230                      section.  */
14231                   asection *code_sec = sec;
14232
14233                   if (get_opd_info (sec) != NULL)
14234                     {
14235                       bfd_vma off = (relocation + addend
14236                                      - sec->output_section->vma
14237                                      - sec->output_offset);
14238
14239                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14240                     }
14241                   if (code_sec == input_section)
14242                     can_plt_call = TRUE;
14243                 }
14244
14245               if (!can_plt_call)
14246                 {
14247                   if (stub_entry->stub_type == ppc_stub_plt_call
14248                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14249                     info->callbacks->einfo
14250                       /* xgettext:c-format */
14251                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14252                          "recompile with -fPIC\n"),
14253                        input_bfd, input_section, rel->r_offset, sym_name);
14254                   else
14255                     info->callbacks->einfo
14256                       /* xgettext:c-format */
14257                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14258                          "(-mcmodel=small toc adjust stub)\n"),
14259                        input_bfd, input_section, rel->r_offset, sym_name);
14260
14261                   bfd_set_error (bfd_error_bad_value);
14262                   ret = FALSE;
14263                 }
14264
14265               if (can_plt_call
14266                   && (stub_entry->stub_type == ppc_stub_plt_call
14267                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14268                 unresolved_reloc = FALSE;
14269             }
14270
14271           if ((stub_entry == NULL
14272                || stub_entry->stub_type == ppc_stub_long_branch
14273                || stub_entry->stub_type == ppc_stub_plt_branch)
14274               && get_opd_info (sec) != NULL)
14275             {
14276               /* The branch destination is the value of the opd entry. */
14277               bfd_vma off = (relocation + addend
14278                              - sec->output_section->vma
14279                              - sec->output_offset);
14280               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14281               if (dest != (bfd_vma) -1)
14282                 {
14283                   relocation = dest;
14284                   addend = 0;
14285                   reloc_dest = DEST_OPD;
14286                 }
14287             }
14288
14289           /* If the branch is out of reach we ought to have a long
14290              branch stub.  */
14291           from = (rel->r_offset
14292                   + input_section->output_offset
14293                   + input_section->output_section->vma);
14294
14295           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14296                                                   ? fdh->elf.other
14297                                                   : sym->st_other);
14298
14299           if (stub_entry != NULL
14300               && (stub_entry->stub_type == ppc_stub_long_branch
14301                   || stub_entry->stub_type == ppc_stub_plt_branch)
14302               && (r_type == R_PPC64_ADDR14_BRTAKEN
14303                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14304                   || (relocation + addend - from + max_br_offset
14305                       < 2 * max_br_offset)))
14306             /* Don't use the stub if this branch is in range.  */
14307             stub_entry = NULL;
14308
14309           if (stub_entry != NULL)
14310             {
14311               /* Munge up the value and addend so that we call the stub
14312                  rather than the procedure directly.  */
14313               asection *stub_sec = stub_entry->group->stub_sec;
14314
14315               if (stub_entry->stub_type == ppc_stub_save_res)
14316                 relocation += (stub_sec->output_offset
14317                                + stub_sec->output_section->vma
14318                                + stub_sec->size - htab->sfpr->size
14319                                - htab->sfpr->output_offset
14320                                - htab->sfpr->output_section->vma);
14321               else
14322                 relocation = (stub_entry->stub_offset
14323                               + stub_sec->output_offset
14324                               + stub_sec->output_section->vma);
14325               addend = 0;
14326               reloc_dest = DEST_STUB;
14327
14328               if ((stub_entry->stub_type == ppc_stub_plt_call
14329                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14330                   && (ALWAYS_EMIT_R2SAVE
14331                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14332                   && rel + 1 < relend
14333                   && rel[1].r_offset == rel->r_offset + 4
14334                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14335                 relocation += 4;
14336             }
14337
14338           if (insn != 0)
14339             {
14340               if (is_isa_v2)
14341                 {
14342                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14343                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14344                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14345                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14346                     insn |= 0x02 << 21;
14347                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14348                     insn |= 0x08 << 21;
14349                   else
14350                     break;
14351                 }
14352               else
14353                 {
14354                   /* Invert 'y' bit if not the default.  */
14355                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14356                     insn ^= 0x01 << 21;
14357                 }
14358
14359               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14360             }
14361
14362           /* NOP out calls to undefined weak functions.
14363              We can thus call a weak function without first
14364              checking whether the function is defined.  */
14365           else if (h != NULL
14366                    && h->elf.root.type == bfd_link_hash_undefweak
14367                    && h->elf.dynindx == -1
14368                    && r_type == R_PPC64_REL24
14369                    && relocation == 0
14370                    && addend == 0)
14371             {
14372               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14373               goto copy_reloc;
14374             }
14375           break;
14376         }
14377
14378       /* Set `addend'.  */
14379       tls_type = 0;
14380       switch (r_type)
14381         {
14382         default:
14383           info->callbacks->einfo
14384             /* xgettext:c-format */
14385             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14386              input_bfd, (int) r_type, sym_name);
14387
14388           bfd_set_error (bfd_error_bad_value);
14389           ret = FALSE;
14390           goto copy_reloc;
14391
14392         case R_PPC64_NONE:
14393         case R_PPC64_TLS:
14394         case R_PPC64_TLSGD:
14395         case R_PPC64_TLSLD:
14396         case R_PPC64_TOCSAVE:
14397         case R_PPC64_GNU_VTINHERIT:
14398         case R_PPC64_GNU_VTENTRY:
14399         case R_PPC64_ENTRY:
14400           goto copy_reloc;
14401
14402           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14403              address in the GOT as relocation value instead of the
14404              symbol's value itself.  Also, create a GOT entry for the
14405              symbol and put the symbol value there.  */
14406         case R_PPC64_GOT_TLSGD16:
14407         case R_PPC64_GOT_TLSGD16_LO:
14408         case R_PPC64_GOT_TLSGD16_HI:
14409         case R_PPC64_GOT_TLSGD16_HA:
14410           tls_type = TLS_TLS | TLS_GD;
14411           goto dogot;
14412
14413         case R_PPC64_GOT_TLSLD16:
14414         case R_PPC64_GOT_TLSLD16_LO:
14415         case R_PPC64_GOT_TLSLD16_HI:
14416         case R_PPC64_GOT_TLSLD16_HA:
14417           tls_type = TLS_TLS | TLS_LD;
14418           goto dogot;
14419
14420         case R_PPC64_GOT_TPREL16_DS:
14421         case R_PPC64_GOT_TPREL16_LO_DS:
14422         case R_PPC64_GOT_TPREL16_HI:
14423         case R_PPC64_GOT_TPREL16_HA:
14424           tls_type = TLS_TLS | TLS_TPREL;
14425           goto dogot;
14426
14427         case R_PPC64_GOT_DTPREL16_DS:
14428         case R_PPC64_GOT_DTPREL16_LO_DS:
14429         case R_PPC64_GOT_DTPREL16_HI:
14430         case R_PPC64_GOT_DTPREL16_HA:
14431           tls_type = TLS_TLS | TLS_DTPREL;
14432           goto dogot;
14433
14434         case R_PPC64_GOT16:
14435         case R_PPC64_GOT16_LO:
14436         case R_PPC64_GOT16_HI:
14437         case R_PPC64_GOT16_HA:
14438         case R_PPC64_GOT16_DS:
14439         case R_PPC64_GOT16_LO_DS:
14440         dogot:
14441           {
14442             /* Relocation is to the entry for this symbol in the global
14443                offset table.  */
14444             asection *got;
14445             bfd_vma *offp;
14446             bfd_vma off;
14447             unsigned long indx = 0;
14448             struct got_entry *ent;
14449
14450             if (tls_type == (TLS_TLS | TLS_LD)
14451                 && (h == NULL
14452                     || !h->elf.def_dynamic))
14453               ent = ppc64_tlsld_got (input_bfd);
14454             else
14455               {
14456                 if (h != NULL)
14457                   {
14458                     if (!htab->elf.dynamic_sections_created
14459                         || h->elf.dynindx == -1
14460                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14461                         || (ELF_ST_VISIBILITY (h->elf.other) != STV_DEFAULT
14462                             && h->elf.root.type == bfd_link_hash_undefweak))
14463                       /* This is actually a static link, or it is a
14464                          -Bsymbolic link and the symbol is defined
14465                          locally, or the symbol was forced to be local
14466                          because of a version file.  */
14467                       ;
14468                     else
14469                       {
14470                         indx = h->elf.dynindx;
14471                         unresolved_reloc = FALSE;
14472                       }
14473                     ent = h->elf.got.glist;
14474                   }
14475                 else
14476                   {
14477                     if (local_got_ents == NULL)
14478                       abort ();
14479                     ent = local_got_ents[r_symndx];
14480                   }
14481
14482                 for (; ent != NULL; ent = ent->next)
14483                   if (ent->addend == orig_rel.r_addend
14484                       && ent->owner == input_bfd
14485                       && ent->tls_type == tls_type)
14486                     break;
14487               }
14488
14489             if (ent == NULL)
14490               abort ();
14491             if (ent->is_indirect)
14492               ent = ent->got.ent;
14493             offp = &ent->got.offset;
14494             got = ppc64_elf_tdata (ent->owner)->got;
14495             if (got == NULL)
14496               abort ();
14497
14498             /* The offset must always be a multiple of 8.  We use the
14499                least significant bit to record whether we have already
14500                processed this entry.  */
14501             off = *offp;
14502             if ((off & 1) != 0)
14503               off &= ~1;
14504             else
14505               {
14506                 /* Generate relocs for the dynamic linker, except in
14507                    the case of TLSLD where we'll use one entry per
14508                    module.  */
14509                 asection *relgot;
14510                 bfd_boolean ifunc;
14511
14512                 *offp = off | 1;
14513                 relgot = NULL;
14514                 ifunc = (h != NULL
14515                          ? h->elf.type == STT_GNU_IFUNC
14516                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14517                 if (ifunc)
14518                   {
14519                     relgot = htab->elf.irelplt;
14520                     if (indx == 0)
14521                       htab->local_ifunc_resolver = 1;
14522                     else if (is_static_defined (&h->elf))
14523                       htab->maybe_local_ifunc_resolver = 1;
14524                   }
14525                 else if (indx != 0
14526                          || (bfd_link_pic (info)
14527                              && (h == NULL
14528                                  || (ELF_ST_VISIBILITY (h->elf.other)
14529                                      == STV_DEFAULT)
14530                                  || h->elf.root.type != bfd_link_hash_undefweak
14531                                  || (tls_type == (TLS_TLS | TLS_LD)
14532                                      && !h->elf.def_dynamic))))
14533                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14534                 if (relgot != NULL)
14535                   {
14536                     outrel.r_offset = (got->output_section->vma
14537                                        + got->output_offset
14538                                        + off);
14539                     outrel.r_addend = addend;
14540                     if (tls_type & (TLS_LD | TLS_GD))
14541                       {
14542                         outrel.r_addend = 0;
14543                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14544                         if (tls_type == (TLS_TLS | TLS_GD))
14545                           {
14546                             loc = relgot->contents;
14547                             loc += (relgot->reloc_count++
14548                                     * sizeof (Elf64_External_Rela));
14549                             bfd_elf64_swap_reloca_out (output_bfd,
14550                                                        &outrel, loc);
14551                             outrel.r_offset += 8;
14552                             outrel.r_addend = addend;
14553                             outrel.r_info
14554                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14555                           }
14556                       }
14557                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14558                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14559                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14560                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14561                     else if (indx != 0)
14562                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14563                     else
14564                       {
14565                         if (ifunc)
14566                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14567                         else
14568                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14569
14570                         /* Write the .got section contents for the sake
14571                            of prelink.  */
14572                         loc = got->contents + off;
14573                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14574                                     loc);
14575                       }
14576
14577                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14578                       {
14579                         outrel.r_addend += relocation;
14580                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14581                           {
14582                             if (htab->elf.tls_sec == NULL)
14583                               outrel.r_addend = 0;
14584                             else
14585                               outrel.r_addend -= htab->elf.tls_sec->vma;
14586                           }
14587                       }
14588                     loc = relgot->contents;
14589                     loc += (relgot->reloc_count++
14590                             * sizeof (Elf64_External_Rela));
14591                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14592                   }
14593
14594                 /* Init the .got section contents here if we're not
14595                    emitting a reloc.  */
14596                 else
14597                   {
14598                     int tlsopt
14599                       = (htab->params->tls_get_addr_opt
14600                          && htab->tls_get_addr_fd != NULL
14601                          && htab->tls_get_addr_fd->elf.plt.plist != NULL);
14602
14603                     relocation += addend;
14604                     if (tls_type != 0)
14605                       {
14606                         if (htab->elf.tls_sec == NULL)
14607                           relocation = 0;
14608                         else
14609                           {
14610                             if (tls_type & TLS_LD)
14611                               relocation = 0;
14612                             else
14613                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14614                             if ((tls_type & TLS_TPREL)
14615                                 || (tlsopt && !(tls_type & TLS_DTPREL)))
14616                               relocation += DTP_OFFSET - TP_OFFSET;
14617                           }
14618
14619                         if (tls_type & (TLS_GD | TLS_LD))
14620                           {
14621                             bfd_put_64 (output_bfd, relocation,
14622                                         got->contents + off + 8);
14623                             relocation = !tlsopt;
14624                           }
14625                       }
14626                     bfd_put_64 (output_bfd, relocation,
14627                                 got->contents + off);
14628                   }
14629               }
14630
14631             if (off >= (bfd_vma) -2)
14632               abort ();
14633
14634             relocation = got->output_section->vma + got->output_offset + off;
14635             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14636           }
14637           break;
14638
14639         case R_PPC64_PLT16_HA:
14640         case R_PPC64_PLT16_HI:
14641         case R_PPC64_PLT16_LO:
14642         case R_PPC64_PLT32:
14643         case R_PPC64_PLT64:
14644           /* Relocation is to the entry for this symbol in the
14645              procedure linkage table.  */
14646           {
14647             struct plt_entry **plt_list = NULL;
14648             if (h != NULL)
14649               plt_list = &h->elf.plt.plist;
14650             else if (local_got_ents != NULL)
14651               {
14652                 struct plt_entry **local_plt = (struct plt_entry **)
14653                   (local_got_ents + symtab_hdr->sh_info);
14654                 unsigned char *local_got_tls_masks = (unsigned char *)
14655                   (local_plt + symtab_hdr->sh_info);
14656                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14657                   plt_list = local_plt + r_symndx;
14658               }
14659             if (plt_list)
14660               {
14661                 struct plt_entry *ent;
14662
14663                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14664                   if (ent->plt.offset != (bfd_vma) -1
14665                       && ent->addend == orig_rel.r_addend)
14666                     {
14667                       asection *plt;
14668
14669                       plt = htab->elf.splt;
14670                       if (!htab->elf.dynamic_sections_created
14671                           || h == NULL
14672                           || h->elf.dynindx == -1)
14673                         plt = htab->elf.iplt;
14674                       relocation = (plt->output_section->vma
14675                                     + plt->output_offset
14676                                     + ent->plt.offset);
14677                       addend = 0;
14678                       unresolved_reloc = FALSE;
14679                       break;
14680                     }
14681               }
14682           }
14683           break;
14684
14685         case R_PPC64_TOC:
14686           /* Relocation value is TOC base.  */
14687           relocation = TOCstart;
14688           if (r_symndx == STN_UNDEF)
14689             relocation += htab->sec_info[input_section->id].toc_off;
14690           else if (unresolved_reloc)
14691             ;
14692           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14693             relocation += htab->sec_info[sec->id].toc_off;
14694           else
14695             unresolved_reloc = TRUE;
14696           goto dodyn;
14697
14698           /* TOC16 relocs.  We want the offset relative to the TOC base,
14699              which is the address of the start of the TOC plus 0x8000.
14700              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14701              in this order.  */
14702         case R_PPC64_TOC16:
14703         case R_PPC64_TOC16_LO:
14704         case R_PPC64_TOC16_HI:
14705         case R_PPC64_TOC16_DS:
14706         case R_PPC64_TOC16_LO_DS:
14707         case R_PPC64_TOC16_HA:
14708           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14709           break;
14710
14711           /* Relocate against the beginning of the section.  */
14712         case R_PPC64_SECTOFF:
14713         case R_PPC64_SECTOFF_LO:
14714         case R_PPC64_SECTOFF_HI:
14715         case R_PPC64_SECTOFF_DS:
14716         case R_PPC64_SECTOFF_LO_DS:
14717         case R_PPC64_SECTOFF_HA:
14718           if (sec != NULL)
14719             addend -= sec->output_section->vma;
14720           break;
14721
14722         case R_PPC64_REL16:
14723         case R_PPC64_REL16_LO:
14724         case R_PPC64_REL16_HI:
14725         case R_PPC64_REL16_HA:
14726         case R_PPC64_REL16DX_HA:
14727           break;
14728
14729         case R_PPC64_REL14:
14730         case R_PPC64_REL14_BRNTAKEN:
14731         case R_PPC64_REL14_BRTAKEN:
14732         case R_PPC64_REL24:
14733           break;
14734
14735         case R_PPC64_TPREL16:
14736         case R_PPC64_TPREL16_LO:
14737         case R_PPC64_TPREL16_HI:
14738         case R_PPC64_TPREL16_HA:
14739         case R_PPC64_TPREL16_DS:
14740         case R_PPC64_TPREL16_LO_DS:
14741         case R_PPC64_TPREL16_HIGH:
14742         case R_PPC64_TPREL16_HIGHA:
14743         case R_PPC64_TPREL16_HIGHER:
14744         case R_PPC64_TPREL16_HIGHERA:
14745         case R_PPC64_TPREL16_HIGHEST:
14746         case R_PPC64_TPREL16_HIGHESTA:
14747           if (h != NULL
14748               && h->elf.root.type == bfd_link_hash_undefweak
14749               && h->elf.dynindx == -1)
14750             {
14751               /* Make this relocation against an undefined weak symbol
14752                  resolve to zero.  This is really just a tweak, since
14753                  code using weak externs ought to check that they are
14754                  defined before using them.  */
14755               bfd_byte *p = contents + rel->r_offset - d_offset;
14756
14757               insn = bfd_get_32 (input_bfd, p);
14758               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14759               if (insn != 0)
14760                 bfd_put_32 (input_bfd, insn, p);
14761               break;
14762             }
14763           if (htab->elf.tls_sec != NULL)
14764             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14765           if (bfd_link_pic (info))
14766             /* The TPREL16 relocs shouldn't really be used in shared
14767                libs as they will result in DT_TEXTREL being set, but
14768                support them anyway.  */
14769             goto dodyn;
14770           break;
14771
14772         case R_PPC64_DTPREL16:
14773         case R_PPC64_DTPREL16_LO:
14774         case R_PPC64_DTPREL16_HI:
14775         case R_PPC64_DTPREL16_HA:
14776         case R_PPC64_DTPREL16_DS:
14777         case R_PPC64_DTPREL16_LO_DS:
14778         case R_PPC64_DTPREL16_HIGH:
14779         case R_PPC64_DTPREL16_HIGHA:
14780         case R_PPC64_DTPREL16_HIGHER:
14781         case R_PPC64_DTPREL16_HIGHERA:
14782         case R_PPC64_DTPREL16_HIGHEST:
14783         case R_PPC64_DTPREL16_HIGHESTA:
14784           if (htab->elf.tls_sec != NULL)
14785             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14786           break;
14787
14788         case R_PPC64_ADDR64_LOCAL:
14789           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14790                                               ? h->elf.other
14791                                               : sym->st_other);
14792           break;
14793
14794         case R_PPC64_DTPMOD64:
14795           relocation = 1;
14796           addend = 0;
14797           goto dodyn;
14798
14799         case R_PPC64_TPREL64:
14800           if (htab->elf.tls_sec != NULL)
14801             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14802           goto dodyn;
14803
14804         case R_PPC64_DTPREL64:
14805           if (htab->elf.tls_sec != NULL)
14806             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14807           /* Fall through.  */
14808
14809           /* Relocations that may need to be propagated if this is a
14810              dynamic object.  */
14811         case R_PPC64_REL30:
14812         case R_PPC64_REL32:
14813         case R_PPC64_REL64:
14814         case R_PPC64_ADDR14:
14815         case R_PPC64_ADDR14_BRNTAKEN:
14816         case R_PPC64_ADDR14_BRTAKEN:
14817         case R_PPC64_ADDR16:
14818         case R_PPC64_ADDR16_DS:
14819         case R_PPC64_ADDR16_HA:
14820         case R_PPC64_ADDR16_HI:
14821         case R_PPC64_ADDR16_HIGH:
14822         case R_PPC64_ADDR16_HIGHA:
14823         case R_PPC64_ADDR16_HIGHER:
14824         case R_PPC64_ADDR16_HIGHERA:
14825         case R_PPC64_ADDR16_HIGHEST:
14826         case R_PPC64_ADDR16_HIGHESTA:
14827         case R_PPC64_ADDR16_LO:
14828         case R_PPC64_ADDR16_LO_DS:
14829         case R_PPC64_ADDR24:
14830         case R_PPC64_ADDR32:
14831         case R_PPC64_ADDR64:
14832         case R_PPC64_UADDR16:
14833         case R_PPC64_UADDR32:
14834         case R_PPC64_UADDR64:
14835         dodyn:
14836           if ((input_section->flags & SEC_ALLOC) == 0)
14837             break;
14838
14839           if (NO_OPD_RELOCS && is_opd)
14840             break;
14841
14842           if (bfd_link_pic (info)
14843               ? ((h == NULL
14844                   || h->dyn_relocs != NULL)
14845                  && ((h != NULL && pc_dynrelocs (h))
14846                      || must_be_dyn_reloc (info, r_type)))
14847               : (h != NULL
14848                  ? h->dyn_relocs != NULL
14849                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14850             {
14851               bfd_boolean skip, relocate;
14852               asection *sreloc;
14853               bfd_vma out_off;
14854               long indx = 0;
14855
14856               /* When generating a dynamic object, these relocations
14857                  are copied into the output file to be resolved at run
14858                  time.  */
14859
14860               skip = FALSE;
14861               relocate = FALSE;
14862
14863               out_off = _bfd_elf_section_offset (output_bfd, info,
14864                                                  input_section, rel->r_offset);
14865               if (out_off == (bfd_vma) -1)
14866                 skip = TRUE;
14867               else if (out_off == (bfd_vma) -2)
14868                 skip = TRUE, relocate = TRUE;
14869               out_off += (input_section->output_section->vma
14870                           + input_section->output_offset);
14871               outrel.r_offset = out_off;
14872               outrel.r_addend = rel->r_addend;
14873
14874               /* Optimize unaligned reloc use.  */
14875               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14876                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14877                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14878               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14879                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14880                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14881               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14882                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14883                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14884
14885               if (skip)
14886                 memset (&outrel, 0, sizeof outrel);
14887               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14888                        && !is_opd
14889                        && r_type != R_PPC64_TOC)
14890                 {
14891                   indx = h->elf.dynindx;
14892                   BFD_ASSERT (indx != -1);
14893                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14894                 }
14895               else
14896                 {
14897                   /* This symbol is local, or marked to become local,
14898                      or this is an opd section reloc which must point
14899                      at a local function.  */
14900                   outrel.r_addend += relocation;
14901                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14902                     {
14903                       if (is_opd && h != NULL)
14904                         {
14905                           /* Lie about opd entries.  This case occurs
14906                              when building shared libraries and we
14907                              reference a function in another shared
14908                              lib.  The same thing happens for a weak
14909                              definition in an application that's
14910                              overridden by a strong definition in a
14911                              shared lib.  (I believe this is a generic
14912                              bug in binutils handling of weak syms.)
14913                              In these cases we won't use the opd
14914                              entry in this lib.  */
14915                           unresolved_reloc = FALSE;
14916                         }
14917                       if (!is_opd
14918                           && r_type == R_PPC64_ADDR64
14919                           && (h != NULL
14920                               ? h->elf.type == STT_GNU_IFUNC
14921                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14922                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14923                       else
14924                         {
14925                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14926
14927                           /* We need to relocate .opd contents for ld.so.
14928                              Prelink also wants simple and consistent rules
14929                              for relocs.  This make all RELATIVE relocs have
14930                              *r_offset equal to r_addend.  */
14931                           relocate = TRUE;
14932                         }
14933                     }
14934                   else
14935                     {
14936                       if (h != NULL
14937                           ? h->elf.type == STT_GNU_IFUNC
14938                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14939                         {
14940                           info->callbacks->einfo
14941                             /* xgettext:c-format */
14942                             (_("%H: %s for indirect "
14943                                "function `%T' unsupported\n"),
14944                              input_bfd, input_section, rel->r_offset,
14945                              ppc64_elf_howto_table[r_type]->name,
14946                              sym_name);
14947                           ret = FALSE;
14948                         }
14949                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14950                         ;
14951                       else if (sec == NULL || sec->owner == NULL)
14952                         {
14953                           bfd_set_error (bfd_error_bad_value);
14954                           return FALSE;
14955                         }
14956                       else
14957                         {
14958                           asection *osec;
14959
14960                           osec = sec->output_section;
14961                           indx = elf_section_data (osec)->dynindx;
14962
14963                           if (indx == 0)
14964                             {
14965                               if ((osec->flags & SEC_READONLY) == 0
14966                                   && htab->elf.data_index_section != NULL)
14967                                 osec = htab->elf.data_index_section;
14968                               else
14969                                 osec = htab->elf.text_index_section;
14970                               indx = elf_section_data (osec)->dynindx;
14971                             }
14972                           BFD_ASSERT (indx != 0);
14973
14974                           /* We are turning this relocation into one
14975                              against a section symbol, so subtract out
14976                              the output section's address but not the
14977                              offset of the input section in the output
14978                              section.  */
14979                           outrel.r_addend -= osec->vma;
14980                         }
14981
14982                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14983                     }
14984                 }
14985
14986               sreloc = elf_section_data (input_section)->sreloc;
14987               if (h != NULL
14988                   ? h->elf.type == STT_GNU_IFUNC
14989                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14990                 {
14991                   sreloc = htab->elf.irelplt;
14992                   if (indx == 0)
14993                     htab->local_ifunc_resolver = 1;
14994                   else if (is_static_defined (&h->elf))
14995                     htab->maybe_local_ifunc_resolver = 1;
14996                 }
14997               if (sreloc == NULL)
14998                 abort ();
14999
15000               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15001                   >= sreloc->size)
15002                 abort ();
15003               loc = sreloc->contents;
15004               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15005               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15006
15007               /* If this reloc is against an external symbol, it will
15008                  be computed at runtime, so there's no need to do
15009                  anything now.  However, for the sake of prelink ensure
15010                  that the section contents are a known value.  */
15011               if (! relocate)
15012                 {
15013                   unresolved_reloc = FALSE;
15014                   /* The value chosen here is quite arbitrary as ld.so
15015                      ignores section contents except for the special
15016                      case of .opd where the contents might be accessed
15017                      before relocation.  Choose zero, as that won't
15018                      cause reloc overflow.  */
15019                   relocation = 0;
15020                   addend = 0;
15021                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15022                      to improve backward compatibility with older
15023                      versions of ld.  */
15024                   if (r_type == R_PPC64_ADDR64)
15025                     addend = outrel.r_addend;
15026                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
15027                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
15028                     addend = outrel.r_offset;
15029                 }
15030             }
15031           else if (r_type == R_PPC64_DTPMOD64
15032                    && htab->params->tls_get_addr_opt
15033                    && htab->tls_get_addr_fd != NULL
15034                    && htab->tls_get_addr_fd->elf.plt.plist != NULL)
15035             {
15036               /* Set up for __tls_get_addr_opt stub, when this entry
15037                  does not have dynamic relocs.  */
15038               relocation = 0;
15039               /* Set up the next word for local dynamic.  If it turns
15040                  out to be global dynamic, the reloc will overwrite
15041                  this value.  */
15042               if (rel->r_offset + 16 <= input_section->size)
15043                 bfd_put_64 (input_bfd, DTP_OFFSET - TP_OFFSET,
15044                             contents + rel->r_offset + 8);
15045             }
15046           else if (r_type == R_PPC64_DTPREL64
15047                    && htab->params->tls_get_addr_opt
15048                    && htab->tls_get_addr_fd != NULL
15049                    && htab->tls_get_addr_fd->elf.plt.plist != NULL
15050                    && rel > relocs
15051                    && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
15052                    && rel[-1].r_offset + 8 == rel->r_offset)
15053             {
15054               /* __tls_get_addr_opt stub value.  */
15055               addend += DTP_OFFSET - TP_OFFSET;
15056             }
15057           break;
15058
15059         case R_PPC64_COPY:
15060         case R_PPC64_GLOB_DAT:
15061         case R_PPC64_JMP_SLOT:
15062         case R_PPC64_JMP_IREL:
15063         case R_PPC64_RELATIVE:
15064           /* We shouldn't ever see these dynamic relocs in relocatable
15065              files.  */
15066           /* Fall through.  */
15067
15068         case R_PPC64_PLTGOT16:
15069         case R_PPC64_PLTGOT16_DS:
15070         case R_PPC64_PLTGOT16_HA:
15071         case R_PPC64_PLTGOT16_HI:
15072         case R_PPC64_PLTGOT16_LO:
15073         case R_PPC64_PLTGOT16_LO_DS:
15074         case R_PPC64_PLTREL32:
15075         case R_PPC64_PLTREL64:
15076           /* These ones haven't been implemented yet.  */
15077
15078           info->callbacks->einfo
15079             /* xgettext:c-format */
15080             (_("%P: %B: %s is not supported for `%T'\n"),
15081              input_bfd,
15082              ppc64_elf_howto_table[r_type]->name, sym_name);
15083
15084           bfd_set_error (bfd_error_invalid_operation);
15085           ret = FALSE;
15086           goto copy_reloc;
15087         }
15088
15089       /* Multi-instruction sequences that access the TOC can be
15090          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15091          to             nop;           addi rb,r2,x;  */
15092       switch (r_type)
15093         {
15094         default:
15095           break;
15096
15097         case R_PPC64_GOT_TLSLD16_HI:
15098         case R_PPC64_GOT_TLSGD16_HI:
15099         case R_PPC64_GOT_TPREL16_HI:
15100         case R_PPC64_GOT_DTPREL16_HI:
15101         case R_PPC64_GOT16_HI:
15102         case R_PPC64_TOC16_HI:
15103           /* These relocs would only be useful if building up an
15104              offset to later add to r2, perhaps in an indexed
15105              addressing mode instruction.  Don't try to optimize.
15106              Unfortunately, the possibility of someone building up an
15107              offset like this or even with the HA relocs, means that
15108              we need to check the high insn when optimizing the low
15109              insn.  */
15110           break;
15111
15112         case R_PPC64_GOT_TLSLD16_HA:
15113         case R_PPC64_GOT_TLSGD16_HA:
15114         case R_PPC64_GOT_TPREL16_HA:
15115         case R_PPC64_GOT_DTPREL16_HA:
15116         case R_PPC64_GOT16_HA:
15117         case R_PPC64_TOC16_HA:
15118           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15119               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15120             {
15121               bfd_byte *p = contents + (rel->r_offset & ~3);
15122               bfd_put_32 (input_bfd, NOP, p);
15123             }
15124           break;
15125
15126         case R_PPC64_GOT_TLSLD16_LO:
15127         case R_PPC64_GOT_TLSGD16_LO:
15128         case R_PPC64_GOT_TPREL16_LO_DS:
15129         case R_PPC64_GOT_DTPREL16_LO_DS:
15130         case R_PPC64_GOT16_LO:
15131         case R_PPC64_GOT16_LO_DS:
15132         case R_PPC64_TOC16_LO:
15133         case R_PPC64_TOC16_LO_DS:
15134           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15135               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15136             {
15137               bfd_byte *p = contents + (rel->r_offset & ~3);
15138               insn = bfd_get_32 (input_bfd, p);
15139               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15140                 {
15141                   /* Transform addic to addi when we change reg.  */
15142                   insn &= ~((0x3f << 26) | (0x1f << 16));
15143                   insn |= (14u << 26) | (2 << 16);
15144                 }
15145               else
15146                 {
15147                   insn &= ~(0x1f << 16);
15148                   insn |= 2 << 16;
15149                 }
15150               bfd_put_32 (input_bfd, insn, p);
15151             }
15152           break;
15153         }
15154
15155       /* Do any further special processing.  */
15156       howto = ppc64_elf_howto_table[(int) r_type];
15157       switch (r_type)
15158         {
15159         default:
15160           break;
15161
15162         case R_PPC64_REL16_HA:
15163         case R_PPC64_REL16DX_HA:
15164         case R_PPC64_ADDR16_HA:
15165         case R_PPC64_ADDR16_HIGHA:
15166         case R_PPC64_ADDR16_HIGHERA:
15167         case R_PPC64_ADDR16_HIGHESTA:
15168         case R_PPC64_TOC16_HA:
15169         case R_PPC64_SECTOFF_HA:
15170         case R_PPC64_TPREL16_HA:
15171         case R_PPC64_TPREL16_HIGHA:
15172         case R_PPC64_TPREL16_HIGHERA:
15173         case R_PPC64_TPREL16_HIGHESTA:
15174         case R_PPC64_DTPREL16_HA:
15175         case R_PPC64_DTPREL16_HIGHA:
15176         case R_PPC64_DTPREL16_HIGHERA:
15177         case R_PPC64_DTPREL16_HIGHESTA:
15178           /* It's just possible that this symbol is a weak symbol
15179              that's not actually defined anywhere. In that case,
15180              'sec' would be NULL, and we should leave the symbol
15181              alone (it will be set to zero elsewhere in the link).  */
15182           if (sec == NULL)
15183             break;
15184           /* Fall through.  */
15185
15186         case R_PPC64_GOT16_HA:
15187         case R_PPC64_PLTGOT16_HA:
15188         case R_PPC64_PLT16_HA:
15189         case R_PPC64_GOT_TLSGD16_HA:
15190         case R_PPC64_GOT_TLSLD16_HA:
15191         case R_PPC64_GOT_TPREL16_HA:
15192         case R_PPC64_GOT_DTPREL16_HA:
15193           /* Add 0x10000 if sign bit in 0:15 is set.
15194              Bits 0:15 are not used.  */
15195           addend += 0x8000;
15196           break;
15197
15198         case R_PPC64_ADDR16_DS:
15199         case R_PPC64_ADDR16_LO_DS:
15200         case R_PPC64_GOT16_DS:
15201         case R_PPC64_GOT16_LO_DS:
15202         case R_PPC64_PLT16_LO_DS:
15203         case R_PPC64_SECTOFF_DS:
15204         case R_PPC64_SECTOFF_LO_DS:
15205         case R_PPC64_TOC16_DS:
15206         case R_PPC64_TOC16_LO_DS:
15207         case R_PPC64_PLTGOT16_DS:
15208         case R_PPC64_PLTGOT16_LO_DS:
15209         case R_PPC64_GOT_TPREL16_DS:
15210         case R_PPC64_GOT_TPREL16_LO_DS:
15211         case R_PPC64_GOT_DTPREL16_DS:
15212         case R_PPC64_GOT_DTPREL16_LO_DS:
15213         case R_PPC64_TPREL16_DS:
15214         case R_PPC64_TPREL16_LO_DS:
15215         case R_PPC64_DTPREL16_DS:
15216         case R_PPC64_DTPREL16_LO_DS:
15217           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15218           mask = 3;
15219           /* If this reloc is against an lq, lxv, or stxv insn, then
15220              the value must be a multiple of 16.  This is somewhat of
15221              a hack, but the "correct" way to do this by defining _DQ
15222              forms of all the _DS relocs bloats all reloc switches in
15223              this file.  It doesn't make much sense to use these
15224              relocs in data, so testing the insn should be safe.  */
15225           if ((insn & (0x3f << 26)) == (56u << 26)
15226               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15227             mask = 15;
15228           relocation += addend;
15229           addend = insn & (mask ^ 3);
15230           if ((relocation & mask) != 0)
15231             {
15232               relocation ^= relocation & mask;
15233               info->callbacks->einfo
15234                 /* xgettext:c-format */
15235                 (_("%H: error: %s not a multiple of %u\n"),
15236                  input_bfd, input_section, rel->r_offset,
15237                  howto->name,
15238                  mask + 1);
15239               bfd_set_error (bfd_error_bad_value);
15240               ret = FALSE;
15241               goto copy_reloc;
15242             }
15243           break;
15244         }
15245
15246       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15247          because such sections are not SEC_ALLOC and thus ld.so will
15248          not process them.  */
15249       if (unresolved_reloc
15250           && !((input_section->flags & SEC_DEBUGGING) != 0
15251                && h->elf.def_dynamic)
15252           && _bfd_elf_section_offset (output_bfd, info, input_section,
15253                                       rel->r_offset) != (bfd_vma) -1)
15254         {
15255           info->callbacks->einfo
15256             /* xgettext:c-format */
15257             (_("%H: unresolvable %s against `%T'\n"),
15258              input_bfd, input_section, rel->r_offset,
15259              howto->name,
15260              h->elf.root.root.string);
15261           ret = FALSE;
15262         }
15263
15264       /* 16-bit fields in insns mostly have signed values, but a
15265          few insns have 16-bit unsigned values.  Really, we should
15266          have different reloc types.  */
15267       if (howto->complain_on_overflow != complain_overflow_dont
15268           && howto->dst_mask == 0xffff
15269           && (input_section->flags & SEC_CODE) != 0)
15270         {
15271           enum complain_overflow complain = complain_overflow_signed;
15272
15273           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15274           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15275             complain = complain_overflow_bitfield;
15276           else if (howto->rightshift == 0
15277                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15278                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15279                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15280                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15281                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15282                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15283             complain = complain_overflow_unsigned;
15284           if (howto->complain_on_overflow != complain)
15285             {
15286               alt_howto = *howto;
15287               alt_howto.complain_on_overflow = complain;
15288               howto = &alt_howto;
15289             }
15290         }
15291
15292       if (r_type == R_PPC64_REL16DX_HA)
15293         {
15294           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15295           if (rel->r_offset + 4 > input_section->size)
15296             r = bfd_reloc_outofrange;
15297           else
15298             {
15299               relocation += addend;
15300               relocation -= (rel->r_offset
15301                              + input_section->output_offset
15302                              + input_section->output_section->vma);
15303               relocation = (bfd_signed_vma) relocation >> 16;
15304               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15305               insn &= ~0x1fffc1;
15306               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15307               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15308               r = bfd_reloc_ok;
15309               if (relocation + 0x8000 > 0xffff)
15310                 r = bfd_reloc_overflow;
15311             }
15312         }
15313       else
15314         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15315                                       rel->r_offset, relocation, addend);
15316
15317       if (r != bfd_reloc_ok)
15318         {
15319           char *more_info = NULL;
15320           const char *reloc_name = howto->name;
15321
15322           if (reloc_dest != DEST_NORMAL)
15323             {
15324               more_info = bfd_malloc (strlen (reloc_name) + 8);
15325               if (more_info != NULL)
15326                 {
15327                   strcpy (more_info, reloc_name);
15328                   strcat (more_info, (reloc_dest == DEST_OPD
15329                                       ? " (OPD)" : " (stub)"));
15330                   reloc_name = more_info;
15331                 }
15332             }
15333
15334           if (r == bfd_reloc_overflow)
15335             {
15336               /* On code like "if (foo) foo();" don't report overflow
15337                  on a branch to zero when foo is undefined.  */
15338               if (!warned
15339                   && (reloc_dest == DEST_STUB
15340                       || !(h != NULL
15341                            && (h->elf.root.type == bfd_link_hash_undefweak
15342                                || h->elf.root.type == bfd_link_hash_undefined)
15343                            && is_branch_reloc (r_type))))
15344                 info->callbacks->reloc_overflow (info, &h->elf.root,
15345                                                  sym_name, reloc_name,
15346                                                  orig_rel.r_addend,
15347                                                  input_bfd, input_section,
15348                                                  rel->r_offset);
15349             }
15350           else
15351             {
15352               info->callbacks->einfo
15353                 /* xgettext:c-format */
15354                 (_("%H: %s against `%T': error %d\n"),
15355                  input_bfd, input_section, rel->r_offset,
15356                  reloc_name, sym_name, (int) r);
15357               ret = FALSE;
15358             }
15359           if (more_info != NULL)
15360             free (more_info);
15361         }
15362     copy_reloc:
15363       if (wrel != rel)
15364         *wrel = *rel;
15365     }
15366
15367   if (wrel != rel)
15368     {
15369       Elf_Internal_Shdr *rel_hdr;
15370       size_t deleted = rel - wrel;
15371
15372       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15373       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15374       if (rel_hdr->sh_size == 0)
15375         {
15376           /* It is too late to remove an empty reloc section.  Leave
15377              one NONE reloc.
15378              ??? What is wrong with an empty section???  */
15379           rel_hdr->sh_size = rel_hdr->sh_entsize;
15380           deleted -= 1;
15381         }
15382       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15383       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15384       input_section->reloc_count -= deleted;
15385     }
15386
15387   /* If we're emitting relocations, then shortly after this function
15388      returns, reloc offsets and addends for this section will be
15389      adjusted.  Worse, reloc symbol indices will be for the output
15390      file rather than the input.  Save a copy of the relocs for
15391      opd_entry_value.  */
15392   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15393     {
15394       bfd_size_type amt;
15395       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15396       rel = bfd_alloc (input_bfd, amt);
15397       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15398       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15399       if (rel == NULL)
15400         return FALSE;
15401       memcpy (rel, relocs, amt);
15402     }
15403   return ret;
15404 }
15405
15406 /* Adjust the value of any local symbols in opd sections.  */
15407
15408 static int
15409 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15410                               const char *name ATTRIBUTE_UNUSED,
15411                               Elf_Internal_Sym *elfsym,
15412                               asection *input_sec,
15413                               struct elf_link_hash_entry *h)
15414 {
15415   struct _opd_sec_data *opd;
15416   long adjust;
15417   bfd_vma value;
15418
15419   if (h != NULL)
15420     return 1;
15421
15422   opd = get_opd_info (input_sec);
15423   if (opd == NULL || opd->adjust == NULL)
15424     return 1;
15425
15426   value = elfsym->st_value - input_sec->output_offset;
15427   if (!bfd_link_relocatable (info))
15428     value -= input_sec->output_section->vma;
15429
15430   adjust = opd->adjust[OPD_NDX (value)];
15431   if (adjust == -1)
15432     return 2;
15433
15434   elfsym->st_value += adjust;
15435   return 1;
15436 }
15437
15438 /* Finish up dynamic symbol handling.  We set the contents of various
15439    dynamic sections here.  */
15440
15441 static bfd_boolean
15442 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15443                                  struct bfd_link_info *info,
15444                                  struct elf_link_hash_entry *h,
15445                                  Elf_Internal_Sym *sym)
15446 {
15447   struct ppc_link_hash_table *htab;
15448   struct plt_entry *ent;
15449   Elf_Internal_Rela rela;
15450   bfd_byte *loc;
15451
15452   htab = ppc_hash_table (info);
15453   if (htab == NULL)
15454     return FALSE;
15455
15456   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15457     if (ent->plt.offset != (bfd_vma) -1)
15458       {
15459         /* This symbol has an entry in the procedure linkage
15460            table.  Set it up.  */
15461         if (!htab->elf.dynamic_sections_created
15462             || h->dynindx == -1)
15463           {
15464             BFD_ASSERT (h->type == STT_GNU_IFUNC
15465                         && h->def_regular
15466                         && (h->root.type == bfd_link_hash_defined
15467                             || h->root.type == bfd_link_hash_defweak));
15468             rela.r_offset = (htab->elf.iplt->output_section->vma
15469                              + htab->elf.iplt->output_offset
15470                              + ent->plt.offset);
15471             if (htab->opd_abi)
15472               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15473             else
15474               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15475             rela.r_addend = (h->root.u.def.value
15476                              + h->root.u.def.section->output_offset
15477                              + h->root.u.def.section->output_section->vma
15478                              + ent->addend);
15479             loc = (htab->elf.irelplt->contents
15480                    + (htab->elf.irelplt->reloc_count++
15481                       * sizeof (Elf64_External_Rela)));
15482             htab->local_ifunc_resolver = 1;
15483           }
15484         else
15485           {
15486             rela.r_offset = (htab->elf.splt->output_section->vma
15487                              + htab->elf.splt->output_offset
15488                              + ent->plt.offset);
15489             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15490             rela.r_addend = ent->addend;
15491             loc = (htab->elf.srelplt->contents
15492                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15493                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15494             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15495               htab->maybe_local_ifunc_resolver = 1;
15496           }
15497         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15498
15499         if (!htab->opd_abi)
15500           {
15501             if (!h->def_regular)
15502               {
15503                 /* Mark the symbol as undefined, rather than as
15504                    defined in glink.  Leave the value if there were
15505                    any relocations where pointer equality matters
15506                    (this is a clue for the dynamic linker, to make
15507                    function pointer comparisons work between an
15508                    application and shared library), otherwise set it
15509                    to zero.  */
15510                 sym->st_shndx = SHN_UNDEF;
15511                 if (!h->pointer_equality_needed)
15512                   sym->st_value = 0;
15513                 else if (!h->ref_regular_nonweak)
15514                   {
15515                     /* This breaks function pointer comparisons, but
15516                        that is better than breaking tests for a NULL
15517                        function pointer.  */
15518                     sym->st_value = 0;
15519                   }
15520               }
15521           }
15522       }
15523
15524   if (h->needs_copy)
15525     {
15526       /* This symbol needs a copy reloc.  Set it up.  */
15527       asection *srel;
15528
15529       if (h->dynindx == -1
15530           || (h->root.type != bfd_link_hash_defined
15531               && h->root.type != bfd_link_hash_defweak)
15532           || htab->elf.srelbss == NULL
15533           || htab->elf.sreldynrelro == NULL)
15534         abort ();
15535
15536       rela.r_offset = (h->root.u.def.value
15537                        + h->root.u.def.section->output_section->vma
15538                        + h->root.u.def.section->output_offset);
15539       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15540       rela.r_addend = 0;
15541       if (h->root.u.def.section == htab->elf.sdynrelro)
15542         srel = htab->elf.sreldynrelro;
15543       else
15544         srel = htab->elf.srelbss;
15545       loc = srel->contents;
15546       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15547       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15548     }
15549
15550   return TRUE;
15551 }
15552
15553 /* Used to decide how to sort relocs in an optimal manner for the
15554    dynamic linker, before writing them out.  */
15555
15556 static enum elf_reloc_type_class
15557 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15558                             const asection *rel_sec,
15559                             const Elf_Internal_Rela *rela)
15560 {
15561   enum elf_ppc64_reloc_type r_type;
15562   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15563
15564   if (rel_sec == htab->elf.irelplt)
15565     return reloc_class_ifunc;
15566
15567   r_type = ELF64_R_TYPE (rela->r_info);
15568   switch (r_type)
15569     {
15570     case R_PPC64_RELATIVE:
15571       return reloc_class_relative;
15572     case R_PPC64_JMP_SLOT:
15573       return reloc_class_plt;
15574     case R_PPC64_COPY:
15575       return reloc_class_copy;
15576     default:
15577       return reloc_class_normal;
15578     }
15579 }
15580
15581 /* Finish up the dynamic sections.  */
15582
15583 static bfd_boolean
15584 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15585                                    struct bfd_link_info *info)
15586 {
15587   struct ppc_link_hash_table *htab;
15588   bfd *dynobj;
15589   asection *sdyn;
15590
15591   htab = ppc_hash_table (info);
15592   if (htab == NULL)
15593     return FALSE;
15594
15595   dynobj = htab->elf.dynobj;
15596   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15597
15598   if (htab->elf.dynamic_sections_created)
15599     {
15600       Elf64_External_Dyn *dyncon, *dynconend;
15601
15602       if (sdyn == NULL || htab->elf.sgot == NULL)
15603         abort ();
15604
15605       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15606       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15607       for (; dyncon < dynconend; dyncon++)
15608         {
15609           Elf_Internal_Dyn dyn;
15610           asection *s;
15611
15612           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15613
15614           switch (dyn.d_tag)
15615             {
15616             default:
15617               continue;
15618
15619             case DT_PPC64_GLINK:
15620               s = htab->glink;
15621               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15622               /* We stupidly defined DT_PPC64_GLINK to be the start
15623                  of glink rather than the first entry point, which is
15624                  what ld.so needs, and now have a bigger stub to
15625                  support automatic multiple TOCs.  */
15626               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15627               break;
15628
15629             case DT_PPC64_OPD:
15630               s = bfd_get_section_by_name (output_bfd, ".opd");
15631               if (s == NULL)
15632                 continue;
15633               dyn.d_un.d_ptr = s->vma;
15634               break;
15635
15636             case DT_PPC64_OPT:
15637               if (htab->do_multi_toc && htab->multi_toc_needed)
15638                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15639               break;
15640
15641             case DT_PPC64_OPDSZ:
15642               s = bfd_get_section_by_name (output_bfd, ".opd");
15643               if (s == NULL)
15644                 continue;
15645               dyn.d_un.d_val = s->size;
15646               break;
15647
15648             case DT_PLTGOT:
15649               s = htab->elf.splt;
15650               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15651               break;
15652
15653             case DT_JMPREL:
15654               s = htab->elf.srelplt;
15655               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15656               break;
15657
15658             case DT_PLTRELSZ:
15659               dyn.d_un.d_val = htab->elf.srelplt->size;
15660               break;
15661
15662             case DT_TEXTREL:
15663               if (htab->local_ifunc_resolver)
15664                 info->callbacks->einfo
15665                   (_("%X%P: text relocations and GNU indirect "
15666                      "functions will result in a segfault at runtime\n"));
15667               else if (htab->maybe_local_ifunc_resolver)
15668                 info->callbacks->einfo
15669                   (_("%P: warning: text relocations and GNU indirect "
15670                      "functions may result in a segfault at runtime\n"));
15671               continue;
15672             }
15673
15674           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15675         }
15676     }
15677
15678   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15679       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15680     {
15681       /* Fill in the first entry in the global offset table.
15682          We use it to hold the link-time TOCbase.  */
15683       bfd_put_64 (output_bfd,
15684                   elf_gp (output_bfd) + TOC_BASE_OFF,
15685                   htab->elf.sgot->contents);
15686
15687       /* Set .got entry size.  */
15688       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15689     }
15690
15691   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15692       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15693     {
15694       /* Set .plt entry size.  */
15695       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15696         = PLT_ENTRY_SIZE (htab);
15697     }
15698
15699   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15700      brlt ourselves if emitrelocations.  */
15701   if (htab->brlt != NULL
15702       && htab->brlt->reloc_count != 0
15703       && !_bfd_elf_link_output_relocs (output_bfd,
15704                                        htab->brlt,
15705                                        elf_section_data (htab->brlt)->rela.hdr,
15706                                        elf_section_data (htab->brlt)->relocs,
15707                                        NULL))
15708     return FALSE;
15709
15710   if (htab->glink != NULL
15711       && htab->glink->reloc_count != 0
15712       && !_bfd_elf_link_output_relocs (output_bfd,
15713                                        htab->glink,
15714                                        elf_section_data (htab->glink)->rela.hdr,
15715                                        elf_section_data (htab->glink)->relocs,
15716                                        NULL))
15717     return FALSE;
15718
15719   if (htab->glink_eh_frame != NULL
15720       && htab->glink_eh_frame->size != 0)
15721     {
15722       bfd_vma val;
15723       bfd_byte *p;
15724       asection *stub_sec;
15725       size_t align = 4;
15726
15727       p = htab->glink_eh_frame->contents;
15728       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15729       for (stub_sec = htab->params->stub_bfd->sections;
15730            stub_sec != NULL;
15731            stub_sec = stub_sec->next)
15732         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15733           {
15734             /* FDE length.  */
15735             p += 4;
15736             /* CIE pointer.  */
15737             p += 4;
15738             /* Offset to stub section.  */
15739             val = (stub_sec->output_section->vma
15740                    + stub_sec->output_offset);
15741             val -= (htab->glink_eh_frame->output_section->vma
15742                     + htab->glink_eh_frame->output_offset
15743                     + (p - htab->glink_eh_frame->contents));
15744             if (val + 0x80000000 > 0xffffffff)
15745               {
15746                 info->callbacks->einfo
15747                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15748                    stub_sec->name);
15749                 return FALSE;
15750               }
15751             bfd_put_32 (dynobj, val, p);
15752             p += 4;
15753             /* stub section size.  */
15754             p += 4;
15755             /* Augmentation.  */
15756             p += 1;
15757             /* Pad.  */
15758             p += ((17 + align - 1) & -align) - 17;
15759           }
15760       if (htab->glink != NULL && htab->glink->size != 0)
15761         {
15762           /* FDE length.  */
15763           p += 4;
15764           /* CIE pointer.  */
15765           p += 4;
15766           /* Offset to .glink.  */
15767           val = (htab->glink->output_section->vma
15768                  + htab->glink->output_offset
15769                  + 8);
15770           val -= (htab->glink_eh_frame->output_section->vma
15771                   + htab->glink_eh_frame->output_offset
15772                   + (p - htab->glink_eh_frame->contents));
15773           if (val + 0x80000000 > 0xffffffff)
15774             {
15775               info->callbacks->einfo
15776                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15777                  htab->glink->name);
15778               return FALSE;
15779             }
15780           bfd_put_32 (dynobj, val, p);
15781           p += 4;
15782           /* .glink size.  */
15783           p += 4;
15784           /* Augmentation.  */
15785           p += 1;
15786           /* Ops.  */
15787           p += 7;
15788           p += ((24 + align - 1) & -align) - 24;
15789         }
15790
15791       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15792           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15793                                                htab->glink_eh_frame,
15794                                                htab->glink_eh_frame->contents))
15795         return FALSE;
15796     }
15797
15798   /* We need to handle writing out multiple GOT sections ourselves,
15799      since we didn't add them to DYNOBJ.  We know dynobj is the first
15800      bfd.  */
15801   while ((dynobj = dynobj->link.next) != NULL)
15802     {
15803       asection *s;
15804
15805       if (!is_ppc64_elf (dynobj))
15806         continue;
15807
15808       s = ppc64_elf_tdata (dynobj)->got;
15809       if (s != NULL
15810           && s->size != 0
15811           && s->output_section != bfd_abs_section_ptr
15812           && !bfd_set_section_contents (output_bfd, s->output_section,
15813                                         s->contents, s->output_offset,
15814                                         s->size))
15815         return FALSE;
15816       s = ppc64_elf_tdata (dynobj)->relgot;
15817       if (s != NULL
15818           && s->size != 0
15819           && s->output_section != bfd_abs_section_ptr
15820           && !bfd_set_section_contents (output_bfd, s->output_section,
15821                                         s->contents, s->output_offset,
15822                                         s->size))
15823         return FALSE;
15824     }
15825
15826   return TRUE;
15827 }
15828
15829 #include "elf64-target.h"
15830
15831 /* FreeBSD support */
15832
15833 #undef  TARGET_LITTLE_SYM
15834 #undef  TARGET_LITTLE_NAME
15835
15836 #undef  TARGET_BIG_SYM
15837 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15838 #undef  TARGET_BIG_NAME
15839 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15840
15841 #undef  ELF_OSABI
15842 #define ELF_OSABI       ELFOSABI_FREEBSD
15843
15844 #undef  elf64_bed
15845 #define elf64_bed       elf64_powerpc_fbsd_bed
15846
15847 #include "elf64-target.h"
15848