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