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