bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2017 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_want_dynrelro 1
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_dtrel_excludes_plt 1
  80 #define elf_backend_default_execstack 0
  81
  82 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  83 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  84 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  87 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  92
  93 #define elf_backend_object_p                  ppc64_elf_object_p
  94 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  95 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  96 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  99 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 100 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 101 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 103 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 104 #define elf_backend_relocs_compatible         _bfd_elf_relocs_compatible
 105 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 106 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 107 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 108 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 109 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 110 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 111 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 112 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 113 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 114 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 115 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 116 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 117 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 118 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 119 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 120 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 121 #define elf_backend_special_sections          ppc64_elf_special_sections
 122 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 123 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 124 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 125
 126 /* The name of the dynamic interpreter.  This is put in the .interp
 127    section.  */
 128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 129
 130 /* The size in bytes of an entry in the procedure linkage table.  */
 131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 132
 133 /* The initial size of the plt reserved for the dynamic linker.  */
 134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 135
 136 /* Offsets to some stack save slots.  */
 137 #define STK_LR 16
 138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 139 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 140    CR save slot.  Used only by optimised __tls_get_addr call stub,
 141    relying on __tls_get_addr_opt not saving CR..  */
 142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 143
 144 /* TOC base pointers offset from start of TOC.  */
 145 #define TOC_BASE_OFF    0x8000
 146 /* TOC base alignment.  */
 147 #define TOC_BASE_ALIGN  256
 148
 149 /* Offset of tp and dtp pointers from start of TLS block.  */
 150 #define TP_OFFSET       0x7000
 151 #define DTP_OFFSET      0x8000
 152
 153 /* .plt call stub instructions.  The normal stub is like this, but
 154    sometimes the .plt entry crosses a 64k boundary and we need to
 155    insert an addi to adjust r11.  */
 156 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 157 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 158 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 159 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 160 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 161 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 162 #define BCTR            0x4e800420      /* bctr                      */
 163
 164 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 165 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 166 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 167
 168 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 169 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 170 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 171 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 172 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 173 #define BNECTR          0x4ca20420      /* bnectr+               */
 174 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 175
 176 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 177 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 178 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 179
 180 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 181 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 182 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 183
 184 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 185 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 186 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 187 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 188 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 189
 190 /* glink call stub instructions.  We enter with the index in R0.  */
 191 #define GLINK_CALL_STUB_SIZE (16*4)
 192                                         /* 0:                           */
 193                                         /*  .quad plt0-1f               */
 194                                         /* __glink:                     */
 195 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 196 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 197                                         /* 1:                           */
 198 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 199                                         /*  ld %2,(0b-1b)(%11)          */
 200 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 201 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 202                                         /*  ld %12,0(%11)               */
 203                                         /*  ld %2,8(%11)                */
 204                                         /*  mtctr %12                   */
 205                                         /*  ld %11,16(%11)              */
 206                                         /*  bctr                        */
 207 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 208 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 209 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 210 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 211 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 212
 213 /* Pad with this.  */
 214 #define NOP             0x60000000
 215
 216 /* Some other nops.  */
 217 #define CROR_151515     0x4def7b82
 218 #define CROR_313131     0x4ffffb82
 219
 220 /* .glink entries for the first 32k functions are two instructions.  */
 221 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 222 #define B_DOT           0x48000000      /* b     .              */
 223
 224 /* After that, we need two instructions to load the index, followed by
 225    a branch.  */
 226 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 227 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 228
 229 /* Instructions used by the save and restore reg functions.  */
 230 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 231 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 232 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 233 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 234 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 235 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 236 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 237 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 238 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 239 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 240 #define BLR             0x4e800020      /* blr                  */
 241
 242 /* Since .opd is an array of descriptors and each entry will end up
 243    with identical R_PPC64_RELATIVE relocs, there is really no need to
 244    propagate .opd relocs;  The dynamic linker should be taught to
 245    relocate .opd without reloc entries.  */
 246 #ifndef NO_OPD_RELOCS
 247 #define NO_OPD_RELOCS 0
 248 #endif
 249
 250 #ifndef ARRAY_SIZE
 251 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 252 #endif
 253
 254 static inline int
 255 abiversion (bfd *abfd)
 256 {
 257   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 258 }
 259
 260 static inline void
 261 set_abiversion (bfd *abfd, int ver)
 262 {
 263   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 264   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 265 }
 266 \f
 267 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 268
 269 /* Relocation HOWTO's.  */
 270 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 271
 272 static reloc_howto_type ppc64_elf_howto_raw[] = {
 273   /* This reloc does nothing.  */
 274   HOWTO (R_PPC64_NONE,          /* type */
 275          0,                     /* rightshift */
 276          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          0,                     /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_dont, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_NONE",        /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0,                     /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* A standard 32 bit relocation.  */
 289   HOWTO (R_PPC64_ADDR32,        /* type */
 290          0,                     /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          32,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_bitfield, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_PPC64_ADDR32",      /* name */
 298          FALSE,                 /* partial_inplace */
 299          0,                     /* src_mask */
 300          0xffffffff,            /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   /* An absolute 26 bit branch; the lower two bits must be zero.
 304      FIXME: we don't check that, we just clear them.  */
 305   HOWTO (R_PPC64_ADDR24,        /* type */
 306          0,                     /* rightshift */
 307          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          26,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR24",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0x03fffffc,            /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A standard 16 bit relocation.  */
 320   HOWTO (R_PPC64_ADDR16,        /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_bitfield, /* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16",      /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* A 16 bit relocation without overflow.  */
 335   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 336          0,                     /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_dont,/* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_LO",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address.  */
 350   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 351          16,                    /* rightshift */
 352          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 353          16,                    /* bitsize */
 354          FALSE,                 /* pc_relative */
 355          0,                     /* bitpos */
 356          complain_overflow_signed, /* complain_on_overflow */
 357          bfd_elf_generic_reloc, /* special_function */
 358          "R_PPC64_ADDR16_HI",   /* name */
 359          FALSE,                 /* partial_inplace */
 360          0,                     /* src_mask */
 361          0xffff,                /* dst_mask */
 362          FALSE),                /* pcrel_offset */
 363
 364   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 365      bits, treated as a signed number, is negative.  */
 366   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 367          16,                    /* rightshift */
 368          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          16,                    /* bitsize */
 370          FALSE,                 /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_signed, /* complain_on_overflow */
 373          ppc64_elf_ha_reloc,    /* special_function */
 374          "R_PPC64_ADDR16_HA",   /* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          FALSE),                /* pcrel_offset */
 379
 380   /* An absolute 16 bit branch; the lower two bits must be zero.
 381      FIXME: we don't check that, we just clear them.  */
 382   HOWTO (R_PPC64_ADDR14,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          16,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_signed, /* complain_on_overflow */
 389          ppc64_elf_branch_reloc, /* special_function */
 390          "R_PPC64_ADDR14",      /* name */
 391          FALSE,                 /* partial_inplace */
 392          0,                     /* src_mask */
 393          0x0000fffc,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   /* An absolute 16 bit branch, for which bit 10 should be set to
 397      indicate that the branch is expected to be taken.  The lower two
 398      bits must be zero.  */
 399   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 400          0,                     /* rightshift */
 401          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 402          16,                    /* bitsize */
 403          FALSE,                 /* pc_relative */
 404          0,                     /* bitpos */
 405          complain_overflow_signed, /* complain_on_overflow */
 406          ppc64_elf_brtaken_reloc, /* special_function */
 407          "R_PPC64_ADDR14_BRTAKEN",/* name */
 408          FALSE,                 /* partial_inplace */
 409          0,                     /* src_mask */
 410          0x0000fffc,            /* dst_mask */
 411          FALSE),                /* pcrel_offset */
 412
 413   /* An absolute 16 bit branch, for which bit 10 should be set to
 414      indicate that the branch is not expected to be taken.  The lower
 415      two bits must be zero.  */
 416   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          16,                    /* bitsize */
 420          FALSE,                 /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_brtaken_reloc, /* special_function */
 424          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x0000fffc,            /* dst_mask */
 428          FALSE),                /* pcrel_offset */
 429
 430   /* A relative 26 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL24,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          26,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL24",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x03fffffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch; the lower two bits must be zero.  */
 446   HOWTO (R_PPC64_REL14,         /* type */
 447          0,                     /* rightshift */
 448          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 449          16,                    /* bitsize */
 450          TRUE,                  /* pc_relative */
 451          0,                     /* bitpos */
 452          complain_overflow_signed, /* complain_on_overflow */
 453          ppc64_elf_branch_reloc, /* special_function */
 454          "R_PPC64_REL14",       /* name */
 455          FALSE,                 /* partial_inplace */
 456          0,                     /* src_mask */
 457          0x0000fffc,            /* dst_mask */
 458          TRUE),                 /* pcrel_offset */
 459
 460   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 461      the branch is expected to be taken.  The lower two bits must be
 462      zero.  */
 463   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 464          0,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          16,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed, /* complain_on_overflow */
 470          ppc64_elf_brtaken_reloc, /* special_function */
 471          "R_PPC64_REL14_BRTAKEN", /* name */
 472          FALSE,                 /* partial_inplace */
 473          0,                     /* src_mask */
 474          0x0000fffc,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 478      the branch is not expected to be taken.  The lower two bits must
 479      be zero.  */
 480   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 481          0,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          16,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed, /* complain_on_overflow */
 487          ppc64_elf_brtaken_reloc, /* special_function */
 488          "R_PPC64_REL14_BRNTAKEN",/* name */
 489          FALSE,                 /* partial_inplace */
 490          0,                     /* src_mask */
 491          0x0000fffc,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 495      symbol.  */
 496   HOWTO (R_PPC64_GOT16,         /* type */
 497          0,                     /* rightshift */
 498          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed, /* complain_on_overflow */
 503          ppc64_elf_unhandled_reloc, /* special_function */
 504          "R_PPC64_GOT16",       /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0xffff,                /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 511      the symbol.  */
 512   HOWTO (R_PPC64_GOT16_LO,      /* type */
 513          0,                     /* rightshift */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          16,                    /* bitsize */
 516          FALSE,                 /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_dont, /* complain_on_overflow */
 519          ppc64_elf_unhandled_reloc, /* special_function */
 520          "R_PPC64_GOT16_LO",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0,                     /* src_mask */
 523          0xffff,                /* dst_mask */
 524          FALSE),                /* pcrel_offset */
 525
 526   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 527      the symbol.  */
 528   HOWTO (R_PPC64_GOT16_HI,      /* type */
 529          16,                    /* rightshift */
 530          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          16,                    /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_signed,/* complain_on_overflow */
 535          ppc64_elf_unhandled_reloc, /* special_function */
 536          "R_PPC64_GOT16_HI",    /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0xffff,                /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 543      the symbol.  */
 544   HOWTO (R_PPC64_GOT16_HA,      /* type */
 545          16,                    /* rightshift */
 546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 547          16,                    /* bitsize */
 548          FALSE,                 /* pc_relative */
 549          0,                     /* bitpos */
 550          complain_overflow_signed,/* complain_on_overflow */
 551          ppc64_elf_unhandled_reloc, /* special_function */
 552          "R_PPC64_GOT16_HA",    /* name */
 553          FALSE,                 /* partial_inplace */
 554          0,                     /* src_mask */
 555          0xffff,                /* dst_mask */
 556          FALSE),                /* pcrel_offset */
 557
 558   /* This is used only by the dynamic linker.  The symbol should exist
 559      both in the object being run and in some shared library.  The
 560      dynamic linker copies the data addressed by the symbol from the
 561      shared library into the object, because the object being
 562      run has to have the data at some particular address.  */
 563   HOWTO (R_PPC64_COPY,          /* type */
 564          0,                     /* rightshift */
 565          0,                     /* this one is variable size */
 566          0,                     /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          ppc64_elf_unhandled_reloc, /* special_function */
 571          "R_PPC64_COPY",        /* name */
 572          FALSE,                 /* partial_inplace */
 573          0,                     /* src_mask */
 574          0,                     /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* Like R_PPC64_ADDR64, but used when setting global offset table
 578      entries.  */
 579   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 580          0,                     /* rightshift */
 581          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 582          64,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          ppc64_elf_unhandled_reloc,  /* special_function */
 587          "R_PPC64_GLOB_DAT",    /* name */
 588          FALSE,                 /* partial_inplace */
 589          0,                     /* src_mask */
 590          ONES (64),             /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* Created by the link editor.  Marks a procedure linkage table
 594      entry for a symbol.  */
 595   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 596          0,                     /* rightshift */
 597          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          0,                     /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_dont, /* complain_on_overflow */
 602          ppc64_elf_unhandled_reloc, /* special_function */
 603          "R_PPC64_JMP_SLOT",    /* name */
 604          FALSE,                 /* partial_inplace */
 605          0,                     /* src_mask */
 606          0,                     /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* Used only by the dynamic linker.  When the object is run, this
 610      doubleword64 is set to the load address of the object, plus the
 611      addend.  */
 612   HOWTO (R_PPC64_RELATIVE,      /* type */
 613          0,                     /* rightshift */
 614          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 615          64,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_dont, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_RELATIVE",    /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          ONES (64),             /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR32,       /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          32,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR32",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffffffff,            /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 642   HOWTO (R_PPC64_UADDR16,       /* type */
 643          0,                     /* rightshift */
 644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          16,                    /* bitsize */
 646          FALSE,                 /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_bitfield, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_UADDR16",     /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffff,                /* dst_mask */
 654          FALSE),                /* pcrel_offset */
 655
 656   /* 32-bit PC relative.  */
 657   HOWTO (R_PPC64_REL32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          TRUE,                  /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_signed, /* complain_on_overflow */
 664          bfd_elf_generic_reloc, /* special_function */
 665          "R_PPC64_REL32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          TRUE),                 /* pcrel_offset */
 670
 671   /* 32-bit relocation to the symbol's procedure linkage table.  */
 672   HOWTO (R_PPC64_PLT32,         /* type */
 673          0,                     /* rightshift */
 674          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 675          32,                    /* bitsize */
 676          FALSE,                 /* pc_relative */
 677          0,                     /* bitpos */
 678          complain_overflow_bitfield, /* complain_on_overflow */
 679          ppc64_elf_unhandled_reloc, /* special_function */
 680          "R_PPC64_PLT32",       /* name */
 681          FALSE,                 /* partial_inplace */
 682          0,                     /* src_mask */
 683          0xffffffff,            /* dst_mask */
 684          FALSE),                /* pcrel_offset */
 685
 686   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 687      FIXME: R_PPC64_PLTREL32 not supported.  */
 688   HOWTO (R_PPC64_PLTREL32,      /* type */
 689          0,                     /* rightshift */
 690          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 691          32,                    /* bitsize */
 692          TRUE,                  /* pc_relative */
 693          0,                     /* bitpos */
 694          complain_overflow_signed, /* complain_on_overflow */
 695          ppc64_elf_unhandled_reloc, /* special_function */
 696          "R_PPC64_PLTREL32",    /* name */
 697          FALSE,                 /* partial_inplace */
 698          0,                     /* src_mask */
 699          0xffffffff,            /* dst_mask */
 700          TRUE),                 /* pcrel_offset */
 701
 702   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 703      the symbol.  */
 704   HOWTO (R_PPC64_PLT16_LO,      /* type */
 705          0,                     /* rightshift */
 706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_dont, /* complain_on_overflow */
 711          ppc64_elf_unhandled_reloc, /* special_function */
 712          "R_PPC64_PLT16_LO",    /* name */
 713          FALSE,                 /* partial_inplace */
 714          0,                     /* src_mask */
 715          0xffff,                /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 719      the symbol.  */
 720   HOWTO (R_PPC64_PLT16_HI,      /* type */
 721          16,                    /* rightshift */
 722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          FALSE,                 /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_signed, /* complain_on_overflow */
 727          ppc64_elf_unhandled_reloc, /* special_function */
 728          "R_PPC64_PLT16_HI",    /* name */
 729          FALSE,                 /* partial_inplace */
 730          0,                     /* src_mask */
 731          0xffff,                /* dst_mask */
 732          FALSE),                /* pcrel_offset */
 733
 734   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 735      the symbol.  */
 736   HOWTO (R_PPC64_PLT16_HA,      /* type */
 737          16,                    /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_unhandled_reloc, /* special_function */
 744          "R_PPC64_PLT16_HA",    /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit section relative relocation.  */
 751   HOWTO (R_PPC64_SECTOFF,       /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_signed, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF",     /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 766   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 767          0,                     /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_dont, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_LO",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HI",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* 16-bit upper half adjusted section relative relocation.  */
 796   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 797          16,                    /* rightshift */
 798          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          16,                    /* bitsize */
 800          FALSE,                 /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_signed, /* complain_on_overflow */
 803          ppc64_elf_sectoff_ha_reloc, /* special_function */
 804          "R_PPC64_SECTOFF_HA",  /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xffff,                /* dst_mask */
 808          FALSE),                /* pcrel_offset */
 809
 810   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 811   HOWTO (R_PPC64_REL30,         /* type */
 812          2,                     /* rightshift */
 813          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 814          30,                    /* bitsize */
 815          TRUE,                  /* pc_relative */
 816          0,                     /* bitpos */
 817          complain_overflow_dont, /* complain_on_overflow */
 818          bfd_elf_generic_reloc, /* special_function */
 819          "R_PPC64_REL30",       /* name */
 820          FALSE,                 /* partial_inplace */
 821          0,                     /* src_mask */
 822          0xfffffffc,            /* dst_mask */
 823          TRUE),                 /* pcrel_offset */
 824
 825   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 826
 827   /* A standard 64-bit relocation.  */
 828   HOWTO (R_PPC64_ADDR64,        /* type */
 829          0,                     /* rightshift */
 830          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 831          64,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR64",      /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          ONES (64),             /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address.  */
 843   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 844          32,                    /* rightshift */
 845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 846          16,                    /* bitsize */
 847          FALSE,                 /* pc_relative */
 848          0,                     /* bitpos */
 849          complain_overflow_dont, /* complain_on_overflow */
 850          bfd_elf_generic_reloc, /* special_function */
 851          "R_PPC64_ADDR16_HIGHER", /* name */
 852          FALSE,                 /* partial_inplace */
 853          0,                     /* src_mask */
 854          0xffff,                /* dst_mask */
 855          FALSE),                /* pcrel_offset */
 856
 857   /* The bits 32-47 of an address, plus 1 if the contents of the low
 858      16 bits, treated as a signed number, is negative.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 860          32,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          ppc64_elf_ha_reloc,    /* special_function */
 867          "R_PPC64_ADDR16_HIGHERA", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address.  */
 874   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 875          48,                    /* rightshift */
 876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 877          16,                    /* bitsize */
 878          FALSE,                 /* pc_relative */
 879          0,                     /* bitpos */
 880          complain_overflow_dont, /* complain_on_overflow */
 881          bfd_elf_generic_reloc, /* special_function */
 882          "R_PPC64_ADDR16_HIGHEST", /* name */
 883          FALSE,                 /* partial_inplace */
 884          0,                     /* src_mask */
 885          0xffff,                /* dst_mask */
 886          FALSE),                /* pcrel_offset */
 887
 888   /* The bits 48-63 of an address, plus 1 if the contents of the low
 889      16 bits, treated as a signed number, is negative.  */
 890   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 891          48,                    /* rightshift */
 892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 893          16,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          ppc64_elf_ha_reloc,    /* special_function */
 898          "R_PPC64_ADDR16_HIGHESTA", /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          0xffff,                /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* Like ADDR64, but may be unaligned.  */
 905   HOWTO (R_PPC64_UADDR64,       /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          FALSE,                 /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_UADDR64",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          FALSE),                /* pcrel_offset */
 918
 919   /* 64-bit relative relocation.  */
 920   HOWTO (R_PPC64_REL64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          TRUE,                  /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_PPC64_REL64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          TRUE),                 /* pcrel_offset */
 933
 934   /* 64-bit relocation to the symbol's procedure linkage table.  */
 935   HOWTO (R_PPC64_PLT64,         /* type */
 936          0,                     /* rightshift */
 937          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 938          64,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_unhandled_reloc, /* special_function */
 943          "R_PPC64_PLT64",       /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          ONES (64),             /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 64-bit PC relative relocation to the symbol's procedure linkage
 950      table.  */
 951   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 952   HOWTO (R_PPC64_PLTREL64,      /* type */
 953          0,                     /* rightshift */
 954          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 955          64,                    /* bitsize */
 956          TRUE,                  /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_unhandled_reloc, /* special_function */
 960          "R_PPC64_PLTREL64",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          ONES (64),             /* dst_mask */
 964          TRUE),                 /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation.  */
 967
 968   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 969   HOWTO (R_PPC64_TOC16,         /* type */
 970          0,                     /* rightshift */
 971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 972          16,                    /* bitsize */
 973          FALSE,                 /* pc_relative */
 974          0,                     /* bitpos */
 975          complain_overflow_signed, /* complain_on_overflow */
 976          ppc64_elf_toc_reloc,   /* special_function */
 977          "R_PPC64_TOC16",       /* name */
 978          FALSE,                 /* partial_inplace */
 979          0,                     /* src_mask */
 980          0xffff,                /* dst_mask */
 981          FALSE),                /* pcrel_offset */
 982
 983   /* 16 bit TOC-relative relocation without overflow.  */
 984
 985   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 986   HOWTO (R_PPC64_TOC16_LO,      /* type */
 987          0,                     /* rightshift */
 988          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 989          16,                    /* bitsize */
 990          FALSE,                 /* pc_relative */
 991          0,                     /* bitpos */
 992          complain_overflow_dont, /* complain_on_overflow */
 993          ppc64_elf_toc_reloc,   /* special_function */
 994          "R_PPC64_TOC16_LO",    /* name */
 995          FALSE,                 /* partial_inplace */
 996          0,                     /* src_mask */
 997          0xffff,                /* dst_mask */
 998          FALSE),                /* pcrel_offset */
 999
1000   /* 16 bit TOC-relative relocation, high 16 bits.  */
1001
1002   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1003   HOWTO (R_PPC64_TOC16_HI,      /* type */
1004          16,                    /* rightshift */
1005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          16,                    /* bitsize */
1007          FALSE,                 /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_signed, /* complain_on_overflow */
1010          ppc64_elf_toc_reloc,   /* special_function */
1011          "R_PPC64_TOC16_HI",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0,                     /* src_mask */
1014          0xffff,                /* dst_mask */
1015          FALSE),                /* pcrel_offset */
1016
1017   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018      contents of the low 16 bits, treated as a signed number, is
1019      negative.  */
1020
1021   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1022   HOWTO (R_PPC64_TOC16_HA,      /* type */
1023          16,                    /* rightshift */
1024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1025          16,                    /* bitsize */
1026          FALSE,                 /* pc_relative */
1027          0,                     /* bitpos */
1028          complain_overflow_signed, /* complain_on_overflow */
1029          ppc64_elf_toc_ha_reloc, /* special_function */
1030          "R_PPC64_TOC16_HA",    /* name */
1031          FALSE,                 /* partial_inplace */
1032          0,                     /* src_mask */
1033          0xffff,                /* dst_mask */
1034          FALSE),                /* pcrel_offset */
1035
1036   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1037
1038   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1039   HOWTO (R_PPC64_TOC,           /* type */
1040          0,                     /* rightshift */
1041          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042          64,                    /* bitsize */
1043          FALSE,                 /* pc_relative */
1044          0,                     /* bitpos */
1045          complain_overflow_dont, /* complain_on_overflow */
1046          ppc64_elf_toc64_reloc, /* special_function */
1047          "R_PPC64_TOC",         /* name */
1048          FALSE,                 /* partial_inplace */
1049          0,                     /* src_mask */
1050          ONES (64),             /* dst_mask */
1051          FALSE),                /* pcrel_offset */
1052
1053   /* Like R_PPC64_GOT16, but also informs the link editor that the
1054      value to relocate may (!) refer to a PLT entry which the link
1055      editor (a) may replace with the symbol value.  If the link editor
1056      is unable to fully resolve the symbol, it may (b) create a PLT
1057      entry and store the address to the new PLT entry in the GOT.
1058      This permits lazy resolution of function symbols at run time.
1059      The link editor may also skip all of this and just (c) emit a
1060      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1061   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1062     HOWTO (R_PPC64_PLTGOT16,    /* type */
1063          0,                     /* rightshift */
1064          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1065          16,                    /* bitsize */
1066          FALSE,                 /* pc_relative */
1067          0,                     /* bitpos */
1068          complain_overflow_signed, /* complain_on_overflow */
1069          ppc64_elf_unhandled_reloc, /* special_function */
1070          "R_PPC64_PLTGOT16",    /* name */
1071          FALSE,                 /* partial_inplace */
1072          0,                     /* src_mask */
1073          0xffff,                /* dst_mask */
1074          FALSE),                /* pcrel_offset */
1075
1076   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1077   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1078   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1079          0,                     /* rightshift */
1080          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1081          16,                    /* bitsize */
1082          FALSE,                 /* pc_relative */
1083          0,                     /* bitpos */
1084          complain_overflow_dont, /* complain_on_overflow */
1085          ppc64_elf_unhandled_reloc, /* special_function */
1086          "R_PPC64_PLTGOT16_LO", /* name */
1087          FALSE,                 /* partial_inplace */
1088          0,                     /* src_mask */
1089          0xffff,                /* dst_mask */
1090          FALSE),                /* pcrel_offset */
1091
1092   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1093   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1094   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1095          16,                    /* rightshift */
1096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1097          16,                    /* bitsize */
1098          FALSE,                 /* pc_relative */
1099          0,                     /* bitpos */
1100          complain_overflow_signed, /* complain_on_overflow */
1101          ppc64_elf_unhandled_reloc, /* special_function */
1102          "R_PPC64_PLTGOT16_HI", /* name */
1103          FALSE,                 /* partial_inplace */
1104          0,                     /* src_mask */
1105          0xffff,                /* dst_mask */
1106          FALSE),                /* pcrel_offset */
1107
1108   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109      1 if the contents of the low 16 bits, treated as a signed number,
1110      is negative.  */
1111   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1112   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1113          16,                    /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          ppc64_elf_unhandled_reloc, /* special_function */
1120          "R_PPC64_PLTGOT16_HA", /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xffff,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_signed, /* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_DS",   /* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_dont,/* complain_on_overflow */
1149          bfd_elf_generic_reloc, /* special_function */
1150          "R_PPC64_ADDR16_LO_DS",/* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_DS,      /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_signed, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_DS",    /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_GOT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont, /* complain_on_overflow */
1194          ppc64_elf_unhandled_reloc, /* special_function */
1195          "R_PPC64_PLT16_LO_DS", /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_signed, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_DS",  /* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont, /* complain_on_overflow */
1224          ppc64_elf_sectoff_reloc, /* special_function */
1225          "R_PPC64_SECTOFF_LO_DS",/* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_DS,      /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_signed, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_DS",    /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1247   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1248          0,                     /* rightshift */
1249          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          16,                    /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont, /* complain_on_overflow */
1254          ppc64_elf_toc_reloc,   /* special_function */
1255          "R_PPC64_TOC16_LO_DS", /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0xfffc,                /* dst_mask */
1259          FALSE),                /* pcrel_offset */
1260
1261   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1262   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1263   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1264          0,                     /* rightshift */
1265          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1266          16,                    /* bitsize */
1267          FALSE,                 /* pc_relative */
1268          0,                     /* bitpos */
1269          complain_overflow_signed, /* complain_on_overflow */
1270          ppc64_elf_unhandled_reloc, /* special_function */
1271          "R_PPC64_PLTGOT16_DS", /* name */
1272          FALSE,                 /* partial_inplace */
1273          0,                     /* src_mask */
1274          0xfffc,                /* dst_mask */
1275          FALSE),                /* pcrel_offset */
1276
1277   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1278   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1279   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280          0,                     /* rightshift */
1281          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          16,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          ppc64_elf_unhandled_reloc, /* special_function */
1287          "R_PPC64_PLTGOT16_LO_DS",/* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0xfffc,                /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   /* Marker relocs for TLS.  */
1294   HOWTO (R_PPC64_TLS,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLS",         /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TLSGD,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TLSGD",       /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   HOWTO (R_PPC64_TLSLD,
1323          0,                     /* rightshift */
1324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1325          32,                    /* bitsize */
1326          FALSE,                 /* pc_relative */
1327          0,                     /* bitpos */
1328          complain_overflow_dont, /* complain_on_overflow */
1329          bfd_elf_generic_reloc, /* special_function */
1330          "R_PPC64_TLSLD",       /* name */
1331          FALSE,                 /* partial_inplace */
1332          0,                     /* src_mask */
1333          0,                     /* dst_mask */
1334          FALSE),                /* pcrel_offset */
1335
1336   HOWTO (R_PPC64_TOCSAVE,
1337          0,                     /* rightshift */
1338          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1339          32,                    /* bitsize */
1340          FALSE,                 /* pc_relative */
1341          0,                     /* bitpos */
1342          complain_overflow_dont, /* complain_on_overflow */
1343          bfd_elf_generic_reloc, /* special_function */
1344          "R_PPC64_TOCSAVE",     /* name */
1345          FALSE,                 /* partial_inplace */
1346          0,                     /* src_mask */
1347          0,                     /* dst_mask */
1348          FALSE),                /* pcrel_offset */
1349
1350   /* Computes the load module index of the load module that contains the
1351      definition of its TLS sym.  */
1352   HOWTO (R_PPC64_DTPMOD64,
1353          0,                     /* rightshift */
1354          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1355          64,                    /* bitsize */
1356          FALSE,                 /* pc_relative */
1357          0,                     /* bitpos */
1358          complain_overflow_dont, /* complain_on_overflow */
1359          ppc64_elf_unhandled_reloc, /* special_function */
1360          "R_PPC64_DTPMOD64",    /* name */
1361          FALSE,                 /* partial_inplace */
1362          0,                     /* src_mask */
1363          ONES (64),             /* dst_mask */
1364          FALSE),                /* pcrel_offset */
1365
1366   /* Computes a dtv-relative displacement, the difference between the value
1367      of sym+add and the base address of the thread-local storage block that
1368      contains the definition of sym, minus 0x8000.  */
1369   HOWTO (R_PPC64_DTPREL64,
1370          0,                     /* rightshift */
1371          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          64,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL64",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          ONES (64),             /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* A 16 bit dtprel reloc.  */
1384   HOWTO (R_PPC64_DTPREL16,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_signed, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16",    /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16, but no overflow.  */
1399   HOWTO (R_PPC64_DTPREL16_LO,
1400          0,                     /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_dont, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_LO", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HI,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HI", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HA,
1430          16,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_signed, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HA", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHER,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHER", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460          32,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHERA", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHEST", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1489   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490          48,                    /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_dont, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xffff,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16, but for insns with a DS field.  */
1504   HOWTO (R_PPC64_DTPREL16_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_signed, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Like DTPREL16_DS, but no overflow.  */
1519   HOWTO (R_PPC64_DTPREL16_LO_DS,
1520          0,                     /* rightshift */
1521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          16,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_dont, /* complain_on_overflow */
1526          ppc64_elf_unhandled_reloc, /* special_function */
1527          "R_PPC64_DTPREL16_LO_DS", /* name */
1528          FALSE,                 /* partial_inplace */
1529          0,                     /* src_mask */
1530          0xfffc,                /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   /* Computes a tp-relative displacement, the difference between the value of
1534      sym+add and the value of the thread pointer (r13).  */
1535   HOWTO (R_PPC64_TPREL64,
1536          0,                     /* rightshift */
1537          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          64,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_dont, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL64",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          ONES (64),             /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* A 16 bit tprel reloc.  */
1550   HOWTO (R_PPC64_TPREL16,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_signed, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16",     /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16, but no overflow.  */
1565   HOWTO (R_PPC64_TPREL16_LO,
1566          0,                     /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_dont, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_LO",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HI,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HI",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HA,
1596          16,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_signed, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HA",  /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHER,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHER",      /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHERA,
1626          32,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHERA", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHEST,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHEST", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1655   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656          48,                    /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_dont, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_HIGHESTA", /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xffff,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16, but for insns with a DS field.  */
1670   HOWTO (R_PPC64_TPREL16_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_signed, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_DS",  /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Like TPREL16_DS, but no overflow.  */
1685   HOWTO (R_PPC64_TPREL16_LO_DS,
1686          0,                     /* rightshift */
1687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1688          16,                    /* bitsize */
1689          FALSE,                 /* pc_relative */
1690          0,                     /* bitpos */
1691          complain_overflow_dont, /* complain_on_overflow */
1692          ppc64_elf_unhandled_reloc, /* special_function */
1693          "R_PPC64_TPREL16_LO_DS", /* name */
1694          FALSE,                 /* partial_inplace */
1695          0,                     /* src_mask */
1696          0xfffc,                /* dst_mask */
1697          FALSE),                /* pcrel_offset */
1698
1699   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701      to the first entry relative to the TOC base (r2).  */
1702   HOWTO (R_PPC64_GOT_TLSGD16,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_signed, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16, but no overflow.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718          0,                     /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_dont, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_LO", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HI", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1747   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1748          16,                    /* rightshift */
1749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1750          16,                    /* bitsize */
1751          FALSE,                 /* pc_relative */
1752          0,                     /* bitpos */
1753          complain_overflow_signed, /* complain_on_overflow */
1754          ppc64_elf_unhandled_reloc, /* special_function */
1755          "R_PPC64_GOT_TLSGD16_HA", /* name */
1756          FALSE,                 /* partial_inplace */
1757          0,                     /* src_mask */
1758          0xffff,                /* dst_mask */
1759          FALSE),                /* pcrel_offset */
1760
1761   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762      with values (sym+add)@dtpmod and zero, and computes the offset to the
1763      first entry relative to the TOC base (r2).  */
1764   HOWTO (R_PPC64_GOT_TLSLD16,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_signed, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16, but no overflow.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780          0,                     /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_dont, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_LO", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HI", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1809   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810          16,                    /* rightshift */
1811          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1812          16,                    /* bitsize */
1813          FALSE,                 /* pc_relative */
1814          0,                     /* bitpos */
1815          complain_overflow_signed, /* complain_on_overflow */
1816          ppc64_elf_unhandled_reloc, /* special_function */
1817          "R_PPC64_GOT_TLSLD16_HA", /* name */
1818          FALSE,                 /* partial_inplace */
1819          0,                     /* src_mask */
1820          0xffff,                /* dst_mask */
1821          FALSE),                /* pcrel_offset */
1822
1823   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824      the offset to the entry relative to the TOC base (r2).  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_signed, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_DS, but no overflow.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841          0,                     /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_dont, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xfffc,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HI", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1870   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871          16,                    /* rightshift */
1872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1873          16,                    /* bitsize */
1874          FALSE,                 /* pc_relative */
1875          0,                     /* bitpos */
1876          complain_overflow_signed, /* complain_on_overflow */
1877          ppc64_elf_unhandled_reloc, /* special_function */
1878          "R_PPC64_GOT_DTPREL16_HA", /* name */
1879          FALSE,                 /* partial_inplace */
1880          0,                     /* src_mask */
1881          0xffff,                /* dst_mask */
1882          FALSE),                /* pcrel_offset */
1883
1884   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885      offset to the entry relative to the TOC base (r2).  */
1886   HOWTO (R_PPC64_GOT_TPREL16_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_signed, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_DS, but no overflow.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902          0,                     /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_dont, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xfffc,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HI,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HI", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1931   HOWTO (R_PPC64_GOT_TPREL16_HA,
1932          16,                    /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_signed, /* complain_on_overflow */
1938          ppc64_elf_unhandled_reloc, /* special_function */
1939          "R_PPC64_GOT_TPREL16_HA", /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   HOWTO (R_PPC64_JMP_IREL,      /* type */
1946          0,                     /* rightshift */
1947          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948          0,                     /* bitsize */
1949          FALSE,                 /* pc_relative */
1950          0,                     /* bitpos */
1951          complain_overflow_dont, /* complain_on_overflow */
1952          ppc64_elf_unhandled_reloc, /* special_function */
1953          "R_PPC64_JMP_IREL",    /* name */
1954          FALSE,                 /* partial_inplace */
1955          0,                     /* src_mask */
1956          0,                     /* dst_mask */
1957          FALSE),                /* pcrel_offset */
1958
1959   HOWTO (R_PPC64_IRELATIVE,     /* type */
1960          0,                     /* rightshift */
1961          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962          64,                    /* bitsize */
1963          FALSE,                 /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_dont, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_IRELATIVE",   /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          ONES (64),             /* dst_mask */
1971          FALSE),                /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation.  */
1974   HOWTO (R_PPC64_REL16,         /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_signed, /* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16",       /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* A 16 bit relative relocation without overflow.  */
1989   HOWTO (R_PPC64_REL16_LO,      /* type */
1990          0,                     /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_dont,/* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_LO",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address.  */
2004   HOWTO (R_PPC64_REL16_HI,      /* type */
2005          16,                    /* rightshift */
2006          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2007          16,                    /* bitsize */
2008          TRUE,                  /* pc_relative */
2009          0,                     /* bitpos */
2010          complain_overflow_signed, /* complain_on_overflow */
2011          bfd_elf_generic_reloc, /* special_function */
2012          "R_PPC64_REL16_HI",    /* name */
2013          FALSE,                 /* partial_inplace */
2014          0,                     /* src_mask */
2015          0xffff,                /* dst_mask */
2016          TRUE),                 /* pcrel_offset */
2017
2018   /* The high order 16 bits of a relative address, plus 1 if the contents of
2019      the low 16 bits, treated as a signed number, is negative.  */
2020   HOWTO (R_PPC64_REL16_HA,      /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          TRUE,                  /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_signed, /* complain_on_overflow */
2027          ppc64_elf_ha_reloc,    /* special_function */
2028          "R_PPC64_REL16_HA",    /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          TRUE),                 /* pcrel_offset */
2033
2034   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2035   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2036          16,                    /* rightshift */
2037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          TRUE,                  /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_signed, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_REL16DX_HA",  /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0x1fffc1,              /* dst_mask */
2047          TRUE),                 /* pcrel_offset */
2048
2049   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2050   HOWTO (R_PPC64_16DX_HA,       /* type */
2051          16,                    /* rightshift */
2052          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_signed, /* complain_on_overflow */
2057          ppc64_elf_ha_reloc,    /* special_function */
2058          "R_PPC64_16DX_HA",     /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0x1fffc1,              /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2065   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          bfd_elf_generic_reloc, /* special_function */
2073          "R_PPC64_ADDR16_HIGH", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2080   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_ha_reloc,    /* special_function */
2088          "R_PPC64_ADDR16_HIGHA",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2095   HOWTO (R_PPC64_DTPREL16_HIGH,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_DTPREL16_HIGH", /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2110   HOWTO (R_PPC64_DTPREL16_HIGHA,
2111          16,                    /* rightshift */
2112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2113          16,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          ppc64_elf_unhandled_reloc, /* special_function */
2118          "R_PPC64_DTPREL16_HIGHA", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          0xffff,                /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2125   HOWTO (R_PPC64_TPREL16_HIGH,
2126          16,                    /* rightshift */
2127          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          16,                    /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          ppc64_elf_unhandled_reloc, /* special_function */
2133          "R_PPC64_TPREL16_HIGH",        /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0xffff,                /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2140   HOWTO (R_PPC64_TPREL16_HIGHA,
2141          16,                    /* rightshift */
2142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          16,                    /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          ppc64_elf_unhandled_reloc, /* special_function */
2148          "R_PPC64_TPREL16_HIGHA",       /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0xffff,                /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153
2154   /* Marker reloc on ELFv2 large-model function entry.  */
2155   HOWTO (R_PPC64_ENTRY,
2156          0,                     /* rightshift */
2157          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2158          32,                    /* bitsize */
2159          FALSE,                 /* pc_relative */
2160          0,                     /* bitpos */
2161          complain_overflow_dont, /* complain_on_overflow */
2162          bfd_elf_generic_reloc, /* special_function */
2163          "R_PPC64_ENTRY",       /* name */
2164          FALSE,                 /* partial_inplace */
2165          0,                     /* src_mask */
2166          0,                     /* dst_mask */
2167          FALSE),                /* pcrel_offset */
2168
2169   /* Like ADDR64, but use local entry point of function.  */
2170   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2171          0,                     /* rightshift */
2172          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173          64,                    /* bitsize */
2174          FALSE,                 /* pc_relative */
2175          0,                     /* bitpos */
2176          complain_overflow_dont, /* complain_on_overflow */
2177          bfd_elf_generic_reloc, /* special_function */
2178          "R_PPC64_ADDR64_LOCAL", /* name */
2179          FALSE,                 /* partial_inplace */
2180          0,                     /* src_mask */
2181          ONES (64),             /* dst_mask */
2182          FALSE),                /* pcrel_offset */
2183
2184   /* GNU extension to record C++ vtable hierarchy.  */
2185   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186          0,                     /* rightshift */
2187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2188          0,                     /* bitsize */
2189          FALSE,                 /* pc_relative */
2190          0,                     /* bitpos */
2191          complain_overflow_dont, /* complain_on_overflow */
2192          NULL,                  /* special_function */
2193          "R_PPC64_GNU_VTINHERIT", /* name */
2194          FALSE,                 /* partial_inplace */
2195          0,                     /* src_mask */
2196          0,                     /* dst_mask */
2197          FALSE),                /* pcrel_offset */
2198
2199   /* GNU extension to record C++ vtable member usage.  */
2200   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2201          0,                     /* rightshift */
2202          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2203          0,                     /* bitsize */
2204          FALSE,                 /* pc_relative */
2205          0,                     /* bitpos */
2206          complain_overflow_dont, /* complain_on_overflow */
2207          NULL,                  /* special_function */
2208          "R_PPC64_GNU_VTENTRY", /* name */
2209          FALSE,                 /* partial_inplace */
2210          0,                     /* src_mask */
2211          0,                     /* dst_mask */
2212          FALSE),                /* pcrel_offset */
2213 };
2214
2215 \f
2216 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217    be done.  */
2218
2219 static void
2220 ppc_howto_init (void)
2221 {
2222   unsigned int i, type;
2223
2224   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225     {
2226       type = ppc64_elf_howto_raw[i].type;
2227       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2228       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229     }
2230 }
2231
2232 static reloc_howto_type *
2233 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234                              bfd_reloc_code_real_type code)
2235 {
2236   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237
2238   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239     /* Initialize howto table if needed.  */
2240     ppc_howto_init ();
2241
2242   switch (code)
2243     {
2244     default:
2245       return NULL;
2246
2247     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2248       break;
2249     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2250       break;
2251     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2252       break;
2253     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2254       break;
2255     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2256       break;
2257     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2258       break;
2259     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2260       break;
2261     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2262       break;
2263     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2264       break;
2265     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2266       break;
2267     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2268       break;
2269     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2270       break;
2271     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2272       break;
2273     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2274       break;
2275     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2276       break;
2277     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2278       break;
2279     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2280       break;
2281     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2282       break;
2283     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2284       break;
2285     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2286       break;
2287     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2288       break;
2289     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2290       break;
2291     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2292       break;
2293     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2294       break;
2295     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2296       break;
2297     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2298       break;
2299     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2300       break;
2301     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2302       break;
2303     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2304       break;
2305     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2306       break;
2307     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2308       break;
2309     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2310       break;
2311     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2312       break;
2313     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2314       break;
2315     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2316       break;
2317     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2318       break;
2319     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2320       break;
2321     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2322       break;
2323     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2324       break;
2325     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2326       break;
2327     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2328       break;
2329     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2330       break;
2331     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2332       break;
2333     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2334       break;
2335     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2336       break;
2337     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2338       break;
2339     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2340       break;
2341     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2342       break;
2343     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2344       break;
2345     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2348       break;
2349     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2350       break;
2351     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2352       break;
2353     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2356       break;
2357     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2358       break;
2359     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2360       break;
2361     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2362       break;
2363     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2364       break;
2365     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2366       break;
2367     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2368       break;
2369     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2370       break;
2371     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2372       break;
2373     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2374       break;
2375     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2376       break;
2377     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2378       break;
2379     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2380       break;
2381     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2384       break;
2385     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2388       break;
2389     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2390       break;
2391     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2392       break;
2393     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2394       break;
2395     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2398       break;
2399     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2402       break;
2403     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2404       break;
2405     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2406       break;
2407     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2408       break;
2409     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2410       break;
2411     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2412       break;
2413     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2414       break;
2415     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2416       break;
2417     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2418       break;
2419     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2420       break;
2421     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2422       break;
2423     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2424       break;
2425     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2426       break;
2427     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2428       break;
2429     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2430       break;
2431     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2432       break;
2433     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2434       break;
2435     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2436       break;
2437     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2438       break;
2439     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2440       break;
2441     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2442       break;
2443     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2444       break;
2445     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2446       break;
2447     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2448       break;
2449     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2450       break;
2451     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2452       break;
2453     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2454       break;
2455     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2456       break;
2457     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2458       break;
2459     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2460       break;
2461     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2462       break;
2463     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2464       break;
2465     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2466       break;
2467     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2468       break;
2469     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2470       break;
2471     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2472       break;
2473     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2474       break;
2475     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2476       break;
2477     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2478       break;
2479     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2480       break;
2481     }
2482
2483   return ppc64_elf_howto_table[r];
2484 };
2485
2486 static reloc_howto_type *
2487 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488                              const char *r_name)
2489 {
2490   unsigned int i;
2491
2492   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2493     if (ppc64_elf_howto_raw[i].name != NULL
2494         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495       return &ppc64_elf_howto_raw[i];
2496
2497   return NULL;
2498 }
2499
2500 /* Set the howto pointer for a PowerPC ELF reloc.  */
2501
2502 static void
2503 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2504                          Elf_Internal_Rela *dst)
2505 {
2506   unsigned int type;
2507
2508   /* Initialize howto table if needed.  */
2509   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2510     ppc_howto_init ();
2511
2512   type = ELF64_R_TYPE (dst->r_info);
2513   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514     {
2515       /* xgettext:c-format */
2516       _bfd_error_handler (_("%B: invalid relocation type %d"),
2517                           abfd, (int) type);
2518       type = R_PPC64_NONE;
2519     }
2520   cache_ptr->howto = ppc64_elf_howto_table[type];
2521 }
2522
2523 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527                     void *data, asection *input_section,
2528                     bfd *output_bfd, char **error_message)
2529 {
2530   enum elf_ppc64_reloc_type r_type;
2531   long insn;
2532   bfd_size_type octets;
2533   bfd_vma value;
2534
2535   /* If this is a relocatable link (output_bfd test tells us), just
2536      call the generic function.  Any adjustment will be done at final
2537      link time.  */
2538   if (output_bfd != NULL)
2539     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540                                   input_section, output_bfd, error_message);
2541
2542   /* Adjust the addend for sign extension of the low 16 bits.
2543      We won't actually be using the low 16 bits, so trashing them
2544      doesn't matter.  */
2545   reloc_entry->addend += 0x8000;
2546   r_type = reloc_entry->howto->type;
2547   if (r_type != R_PPC64_REL16DX_HA)
2548     return bfd_reloc_continue;
2549
2550   value = 0;
2551   if (!bfd_is_com_section (symbol->section))
2552     value = symbol->value;
2553   value += (reloc_entry->addend
2554             + symbol->section->output_offset
2555             + symbol->section->output_section->vma);
2556   value -= (reloc_entry->address
2557             + input_section->output_offset
2558             + input_section->output_section->vma);
2559   value = (bfd_signed_vma) value >> 16;
2560
2561   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563   insn &= ~0x1fffc1;
2564   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2565   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2566   if (value + 0x8000 > 0xffff)
2567     return bfd_reloc_overflow;
2568   return bfd_reloc_ok;
2569 }
2570
2571 static bfd_reloc_status_type
2572 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573                         void *data, asection *input_section,
2574                         bfd *output_bfd, char **error_message)
2575 {
2576   if (output_bfd != NULL)
2577     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578                                   input_section, output_bfd, error_message);
2579
2580   if (strcmp (symbol->section->name, ".opd") == 0
2581       && (symbol->section->owner->flags & DYNAMIC) == 0)
2582     {
2583       bfd_vma dest = opd_entry_value (symbol->section,
2584                                       symbol->value + reloc_entry->addend,
2585                                       NULL, NULL, FALSE);
2586       if (dest != (bfd_vma) -1)
2587         reloc_entry->addend = dest - (symbol->value
2588                                       + symbol->section->output_section->vma
2589                                       + symbol->section->output_offset);
2590     }
2591   else
2592     {
2593       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595       if (symbol->section->owner != abfd
2596           && symbol->section->owner != NULL
2597           && abiversion (symbol->section->owner) >= 2)
2598         {
2599           unsigned int i;
2600
2601           for (i = 0; i < symbol->section->owner->symcount; ++i)
2602             {
2603               asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605               if (strcmp (symdef->name, symbol->name) == 0)
2606                 {
2607                   elfsym = (elf_symbol_type *) symdef;
2608                   break;
2609                 }
2610             }
2611         }
2612       reloc_entry->addend
2613         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614     }
2615   return bfd_reloc_continue;
2616 }
2617
2618 static bfd_reloc_status_type
2619 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620                          void *data, asection *input_section,
2621                          bfd *output_bfd, char **error_message)
2622 {
2623   long insn;
2624   enum elf_ppc64_reloc_type r_type;
2625   bfd_size_type octets;
2626   /* Assume 'at' branch hints.  */
2627   bfd_boolean is_isa_v2 = TRUE;
2628
2629   /* If this is a relocatable link (output_bfd test tells us), just
2630      call the generic function.  Any adjustment will be done at final
2631      link time.  */
2632   if (output_bfd != NULL)
2633     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2634                                   input_section, output_bfd, error_message);
2635
2636   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638   insn &= ~(0x01 << 21);
2639   r_type = reloc_entry->howto->type;
2640   if (r_type == R_PPC64_ADDR14_BRTAKEN
2641       || r_type == R_PPC64_REL14_BRTAKEN)
2642     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2643
2644   if (is_isa_v2)
2645     {
2646       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2647          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2649       if ((insn & (0x14 << 21)) == (0x04 << 21))
2650         insn |= 0x02 << 21;
2651       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652         insn |= 0x08 << 21;
2653       else
2654         goto out;
2655     }
2656   else
2657     {
2658       bfd_vma target = 0;
2659       bfd_vma from;
2660
2661       if (!bfd_is_com_section (symbol->section))
2662         target = symbol->value;
2663       target += symbol->section->output_section->vma;
2664       target += symbol->section->output_offset;
2665       target += reloc_entry->addend;
2666
2667       from = (reloc_entry->address
2668               + input_section->output_offset
2669               + input_section->output_section->vma);
2670
2671       /* Invert 'y' bit if not the default.  */
2672       if ((bfd_signed_vma) (target - from) < 0)
2673         insn ^= 0x01 << 21;
2674     }
2675   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676  out:
2677   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678                                  input_section, output_bfd, error_message);
2679 }
2680
2681 static bfd_reloc_status_type
2682 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683                          void *data, asection *input_section,
2684                          bfd *output_bfd, char **error_message)
2685 {
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   /* Subtract the symbol section base address.  */
2694   reloc_entry->addend -= symbol->section->output_section->vma;
2695   return bfd_reloc_continue;
2696 }
2697
2698 static bfd_reloc_status_type
2699 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700                             void *data, asection *input_section,
2701                             bfd *output_bfd, char **error_message)
2702 {
2703   /* If this is a relocatable link (output_bfd test tells us), just
2704      call the generic function.  Any adjustment will be done at final
2705      link time.  */
2706   if (output_bfd != NULL)
2707     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708                                   input_section, output_bfd, error_message);
2709
2710   /* Subtract the symbol section base address.  */
2711   reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713   /* Adjust the addend for sign extension of the low 16 bits.  */
2714   reloc_entry->addend += 0x8000;
2715   return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720                      void *data, asection *input_section,
2721                      bfd *output_bfd, char **error_message)
2722 {
2723   bfd_vma TOCstart;
2724
2725   /* If this is a relocatable link (output_bfd test tells us), just
2726      call the generic function.  Any adjustment will be done at final
2727      link time.  */
2728   if (output_bfd != NULL)
2729     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730                                   input_section, output_bfd, error_message);
2731
2732   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733   if (TOCstart == 0)
2734     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736   /* Subtract the TOC base address.  */
2737   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738   return bfd_reloc_continue;
2739 }
2740
2741 static bfd_reloc_status_type
2742 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743                         void *data, asection *input_section,
2744                         bfd *output_bfd, char **error_message)
2745 {
2746   bfd_vma TOCstart;
2747
2748   /* If this is a relocatable link (output_bfd test tells us), just
2749      call the generic function.  Any adjustment will be done at final
2750      link time.  */
2751   if (output_bfd != NULL)
2752     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2753                                   input_section, output_bfd, error_message);
2754
2755   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756   if (TOCstart == 0)
2757     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758
2759   /* Subtract the TOC base address.  */
2760   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762   /* Adjust the addend for sign extension of the low 16 bits.  */
2763   reloc_entry->addend += 0x8000;
2764   return bfd_reloc_continue;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769                        void *data, asection *input_section,
2770                        bfd *output_bfd, char **error_message)
2771 {
2772   bfd_vma TOCstart;
2773   bfd_size_type octets;
2774
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783   if (TOCstart == 0)
2784     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785
2786   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788   return bfd_reloc_ok;
2789 }
2790
2791 static bfd_reloc_status_type
2792 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793                            void *data, asection *input_section,
2794                            bfd *output_bfd, char **error_message)
2795 {
2796   /* If this is a relocatable link (output_bfd test tells us), just
2797      call the generic function.  Any adjustment will be done at final
2798      link time.  */
2799   if (output_bfd != NULL)
2800     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2801                                   input_section, output_bfd, error_message);
2802
2803   if (error_message != NULL)
2804     {
2805       static char buf[60];
2806       sprintf (buf, "generic linker can't handle %s",
2807                reloc_entry->howto->name);
2808       *error_message = buf;
2809     }
2810   return bfd_reloc_dangerous;
2811 }
2812
2813 /* Track GOT entries needed for a given symbol.  We might need more
2814    than one got entry per symbol.  */
2815 struct got_entry
2816 {
2817   struct got_entry *next;
2818
2819   /* The symbol addend that we'll be placing in the GOT.  */
2820   bfd_vma addend;
2821
2822   /* Unlike other ELF targets, we use separate GOT entries for the same
2823      symbol referenced from different input files.  This is to support
2824      automatic multiple TOC/GOT sections, where the TOC base can vary
2825      from one input file to another.  After partitioning into TOC groups
2826      we merge entries within the group.
2827
2828      Point to the BFD owning this GOT entry.  */
2829   bfd *owner;
2830
2831   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832      TLS_TPREL or TLS_DTPREL for tls entries.  */
2833   unsigned char tls_type;
2834
2835   /* Non-zero if got.ent points to real entry.  */
2836   unsigned char is_indirect;
2837
2838   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2839   union
2840     {
2841       bfd_signed_vma refcount;
2842       bfd_vma offset;
2843       struct got_entry *ent;
2844     } got;
2845 };
2846
2847 /* The same for PLT.  */
2848 struct plt_entry
2849 {
2850   struct plt_entry *next;
2851
2852   bfd_vma addend;
2853
2854   union
2855     {
2856       bfd_signed_vma refcount;
2857       bfd_vma offset;
2858     } plt;
2859 };
2860
2861 struct ppc64_elf_obj_tdata
2862 {
2863   struct elf_obj_tdata elf;
2864
2865   /* Shortcuts to dynamic linker sections.  */
2866   asection *got;
2867   asection *relgot;
2868
2869   /* Used during garbage collection.  We attach global symbols defined
2870      on removed .opd entries to this section so that the sym is removed.  */
2871   asection *deleted_section;
2872
2873   /* TLS local dynamic got entry handling.  Support for multiple GOT
2874      sections means we potentially need one of these for each input bfd.  */
2875   struct got_entry tlsld_got;
2876
2877   union {
2878     /* A copy of relocs before they are modified for --emit-relocs.  */
2879     Elf_Internal_Rela *relocs;
2880
2881     /* Section contents.  */
2882     bfd_byte *contents;
2883   } opd;
2884
2885   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886      the reloc to be in the range -32768 to 32767.  */
2887   unsigned int has_small_toc_reloc : 1;
2888
2889   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890      instruction not one we handle.  */
2891   unsigned int unexpected_toc_insn : 1;
2892 };
2893
2894 #define ppc64_elf_tdata(bfd) \
2895   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897 #define ppc64_tlsld_got(bfd) \
2898   (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
2900 #define is_ppc64_elf(bfd) \
2901   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2902    && elf_object_id (bfd) == PPC64_ELF_DATA)
2903
2904 /* Override the generic function because we store some extras.  */
2905
2906 static bfd_boolean
2907 ppc64_elf_mkobject (bfd *abfd)
2908 {
2909   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2910                                   PPC64_ELF_DATA);
2911 }
2912
2913 /* Fix bad default arch selected for a 64 bit input bfd when the
2914    default is 32 bit.  Also select arch based on apuinfo.  */
2915
2916 static bfd_boolean
2917 ppc64_elf_object_p (bfd *abfd)
2918 {
2919   if (!abfd->arch_info->the_default)
2920     return TRUE;
2921
2922   if (abfd->arch_info->bits_per_word == 32)
2923     {
2924       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927         {
2928           /* Relies on arch after 32 bit default being 64 bit default.  */
2929           abfd->arch_info = abfd->arch_info->next;
2930           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931         }
2932     }
2933   return _bfd_elf_ppc_set_arch (abfd);
2934 }
2935
2936 /* Support for core dump NOTE sections.  */
2937
2938 static bfd_boolean
2939 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941   size_t offset, size;
2942
2943   if (note->descsz != 504)
2944     return FALSE;
2945
2946   /* pr_cursig */
2947   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2948
2949   /* pr_pid */
2950   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2951
2952   /* pr_reg */
2953   offset = 112;
2954   size = 384;
2955
2956   /* Make a ".reg/999" section.  */
2957   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2958                                           size, note->descpos + offset);
2959 }
2960
2961 static bfd_boolean
2962 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 {
2964   if (note->descsz != 136)
2965     return FALSE;
2966
2967   elf_tdata (abfd)->core->pid
2968     = bfd_get_32 (abfd, note->descdata + 24);
2969   elf_tdata (abfd)->core->program
2970     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2971   elf_tdata (abfd)->core->command
2972     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974   return TRUE;
2975 }
2976
2977 static char *
2978 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979                            ...)
2980 {
2981   switch (note_type)
2982     {
2983     default:
2984       return NULL;
2985
2986     case NT_PRPSINFO:
2987       {
2988         char data[136];
2989         va_list ap;
2990
2991         va_start (ap, note_type);
2992         memset (data, 0, sizeof (data));
2993         strncpy (data + 40, va_arg (ap, const char *), 16);
2994         strncpy (data + 56, va_arg (ap, const char *), 80);
2995         va_end (ap);
2996         return elfcore_write_note (abfd, buf, bufsiz,
2997                                    "CORE", note_type, data, sizeof (data));
2998       }
2999
3000     case NT_PRSTATUS:
3001       {
3002         char data[504];
3003         va_list ap;
3004         long pid;
3005         int cursig;
3006         const void *greg;
3007
3008         va_start (ap, note_type);
3009         memset (data, 0, 112);
3010         pid = va_arg (ap, long);
3011         bfd_put_32 (abfd, pid, data + 32);
3012         cursig = va_arg (ap, int);
3013         bfd_put_16 (abfd, cursig, data + 12);
3014         greg = va_arg (ap, const void *);
3015         memcpy (data + 112, greg, 384);
3016         memset (data + 496, 0, 8);
3017         va_end (ap);
3018         return elfcore_write_note (abfd, buf, bufsiz,
3019                                    "CORE", note_type, data, sizeof (data));
3020       }
3021     }
3022 }
3023
3024 /* Add extra PPC sections.  */
3025
3026 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 {
3028   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3029   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3034   { NULL,                     0,  0, 0,            0 }
3035 };
3036
3037 enum _ppc64_sec_type {
3038   sec_normal = 0,
3039   sec_opd = 1,
3040   sec_toc = 2
3041 };
3042
3043 struct _ppc64_elf_section_data
3044 {
3045   struct bfd_elf_section_data elf;
3046
3047   union
3048   {
3049     /* An array with one entry for each opd function descriptor,
3050        and some spares since opd entries may be either 16 or 24 bytes.  */
3051 #define OPD_NDX(OFF) ((OFF) >> 4)
3052     struct _opd_sec_data
3053     {
3054       /* Points to the function code section for local opd entries.  */
3055       asection **func_sec;
3056
3057       /* After editing .opd, adjust references to opd local syms.  */
3058       long *adjust;
3059     } opd;
3060
3061     /* An array for toc sections, indexed by offset/8.  */
3062     struct _toc_sec_data
3063     {
3064       /* Specifies the relocation symbol index used at a given toc offset.  */
3065       unsigned *symndx;
3066
3067       /* And the relocation addend.  */
3068       bfd_vma *add;
3069     } toc;
3070   } u;
3071
3072   enum _ppc64_sec_type sec_type:2;
3073
3074   /* Flag set when small branches are detected.  Used to
3075      select suitable defaults for the stub group size.  */
3076   unsigned int has_14bit_branch:1;
3077 };
3078
3079 #define ppc64_elf_section_data(sec) \
3080   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3081
3082 static bfd_boolean
3083 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 {
3085   if (!sec->used_by_bfd)
3086     {
3087       struct _ppc64_elf_section_data *sdata;
3088       bfd_size_type amt = sizeof (*sdata);
3089
3090       sdata = bfd_zalloc (abfd, amt);
3091       if (sdata == NULL)
3092         return FALSE;
3093       sec->used_by_bfd = sdata;
3094     }
3095
3096   return _bfd_elf_new_section_hook (abfd, sec);
3097 }
3098
3099 static struct _opd_sec_data *
3100 get_opd_info (asection * sec)
3101 {
3102   if (sec != NULL
3103       && ppc64_elf_section_data (sec) != NULL
3104       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3105     return &ppc64_elf_section_data (sec)->u.opd;
3106   return NULL;
3107 }
3108 \f
3109 /* Parameters for the qsort hook.  */
3110 static bfd_boolean synthetic_relocatable;
3111 static asection *synthetic_opd;
3112
3113 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3114
3115 static int
3116 compare_symbols (const void *ap, const void *bp)
3117 {
3118   const asymbol *a = * (const asymbol **) ap;
3119   const asymbol *b = * (const asymbol **) bp;
3120
3121   /* Section symbols first.  */
3122   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123     return -1;
3124   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3125     return 1;
3126
3127   /* then .opd symbols.  */
3128   if (synthetic_opd != NULL)
3129     {
3130       if (strcmp (a->section->name, ".opd") == 0
3131           && strcmp (b->section->name, ".opd") != 0)
3132         return -1;
3133       if (strcmp (a->section->name, ".opd") != 0
3134           && strcmp (b->section->name, ".opd") == 0)
3135         return 1;
3136     }
3137
3138   /* then other code symbols.  */
3139   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140       == (SEC_CODE | SEC_ALLOC)
3141       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142          != (SEC_CODE | SEC_ALLOC))
3143     return -1;
3144
3145   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146       != (SEC_CODE | SEC_ALLOC)
3147       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148          == (SEC_CODE | SEC_ALLOC))
3149     return 1;
3150
3151   if (synthetic_relocatable)
3152     {
3153       if (a->section->id < b->section->id)
3154         return -1;
3155
3156       if (a->section->id > b->section->id)
3157         return 1;
3158     }
3159
3160   if (a->value + a->section->vma < b->value + b->section->vma)
3161     return -1;
3162
3163   if (a->value + a->section->vma > b->value + b->section->vma)
3164     return 1;
3165
3166   /* For syms with the same value, prefer strong dynamic global function
3167      syms over other syms.  */
3168   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169     return -1;
3170
3171   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172     return 1;
3173
3174   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175     return -1;
3176
3177   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178     return 1;
3179
3180   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181     return -1;
3182
3183   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184     return 1;
3185
3186   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187     return -1;
3188
3189   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190     return 1;
3191
3192   return a > b;
3193 }
3194
3195 /* Search SYMS for a symbol of the given VALUE.  */
3196
3197 static asymbol *
3198 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3199 {
3200   long mid;
3201
3202   if (id == (unsigned) -1)
3203     {
3204       while (lo < hi)
3205         {
3206           mid = (lo + hi) >> 1;
3207           if (syms[mid]->value + syms[mid]->section->vma < value)
3208             lo = mid + 1;
3209           else if (syms[mid]->value + syms[mid]->section->vma > value)
3210             hi = mid;
3211           else
3212             return syms[mid];
3213         }
3214     }
3215   else
3216     {
3217       while (lo < hi)
3218         {
3219           mid = (lo + hi) >> 1;
3220           if (syms[mid]->section->id < id)
3221             lo = mid + 1;
3222           else if (syms[mid]->section->id > id)
3223             hi = mid;
3224           else if (syms[mid]->value < value)
3225             lo = mid + 1;
3226           else if (syms[mid]->value > value)
3227             hi = mid;
3228           else
3229             return syms[mid];
3230         }
3231     }
3232   return NULL;
3233 }
3234
3235 static bfd_boolean
3236 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 {
3238   bfd_vma vma = *(bfd_vma *) ptr;
3239   return ((section->flags & SEC_ALLOC) != 0
3240           && section->vma <= vma
3241           && vma < section->vma + section->size);
3242 }
3243
3244 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3245    entry syms.  Also generate @plt symbols for the glink branch table.
3246    Returns count of synthetic symbols in RET or -1 on error.  */
3247
3248 static long
3249 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250                                 long static_count, asymbol **static_syms,
3251                                 long dyn_count, asymbol **dyn_syms,
3252                                 asymbol **ret)
3253 {
3254   asymbol *s;
3255   long i;
3256   long count;
3257   char *names;
3258   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3259   asection *opd = NULL;
3260   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261   asymbol **syms;
3262   int abi = abiversion (abfd);
3263
3264   *ret = NULL;
3265
3266   if (abi < 2)
3267     {
3268       opd = bfd_get_section_by_name (abfd, ".opd");
3269       if (opd == NULL && abi == 1)
3270         return 0;
3271     }
3272
3273   syms = NULL;
3274   codesecsym = 0;
3275   codesecsymend = 0;
3276   secsymend = 0;
3277   opdsymend = 0;
3278   symcount = 0;
3279   if (opd != NULL)
3280     {
3281       symcount = static_count;
3282       if (!relocatable)
3283         symcount += dyn_count;
3284       if (symcount == 0)
3285         return 0;
3286
3287       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3288       if (syms == NULL)
3289         return -1;
3290
3291       if (!relocatable && static_count != 0 && dyn_count != 0)
3292         {
3293           /* Use both symbol tables.  */
3294           memcpy (syms, static_syms, static_count * sizeof (*syms));
3295           memcpy (syms + static_count, dyn_syms,
3296                   (dyn_count + 1) * sizeof (*syms));
3297         }
3298       else if (!relocatable && static_count == 0)
3299         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3300       else
3301         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3302
3303       synthetic_relocatable = relocatable;
3304       synthetic_opd = opd;
3305       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3306
3307       if (!relocatable && symcount > 1)
3308         {
3309           long j;
3310           /* Trim duplicate syms, since we may have merged the normal and
3311              dynamic symbols.  Actually, we only care about syms that have
3312              different values, so trim any with the same value.  */
3313           for (i = 1, j = 1; i < symcount; ++i)
3314             if (syms[i - 1]->value + syms[i - 1]->section->vma
3315                 != syms[i]->value + syms[i]->section->vma)
3316               syms[j++] = syms[i];
3317           symcount = j;
3318         }
3319
3320       i = 0;
3321       /* Note that here and in compare_symbols we can't compare opd and
3322          sym->section directly.  With separate debug info files, the
3323          symbols will be extracted from the debug file while abfd passed
3324          to this function is the real binary.  */
3325       if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3326         ++i;
3327       codesecsym = i;
3328
3329       for (; i < symcount; ++i)
3330         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3331                                          | SEC_THREAD_LOCAL))
3332              != (SEC_CODE | SEC_ALLOC))
3333             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3334           break;
3335       codesecsymend = i;
3336
3337       for (; i < symcount; ++i)
3338         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3339           break;
3340       secsymend = i;
3341
3342       for (; i < symcount; ++i)
3343         if (strcmp (syms[i]->section->name, ".opd") != 0)
3344           break;
3345       opdsymend = i;
3346
3347       for (; i < symcount; ++i)
3348         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3349             != (SEC_CODE | SEC_ALLOC))
3350           break;
3351       symcount = i;
3352     }
3353   count = 0;
3354
3355   if (relocatable)
3356     {
3357       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3358       arelent *r;
3359       size_t size;
3360       long relcount;
3361
3362       if (opdsymend == secsymend)
3363         goto done;
3364
3365       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3366       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3367       if (relcount == 0)
3368         goto done;
3369
3370       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3371         {
3372           count = -1;
3373           goto done;
3374         }
3375
3376       size = 0;
3377       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3378         {
3379           asymbol *sym;
3380
3381           while (r < opd->relocation + relcount
3382                  && r->address < syms[i]->value + opd->vma)
3383             ++r;
3384
3385           if (r == opd->relocation + relcount)
3386             break;
3387
3388           if (r->address != syms[i]->value + opd->vma)
3389             continue;
3390
3391           if (r->howto->type != R_PPC64_ADDR64)
3392             continue;
3393
3394           sym = *r->sym_ptr_ptr;
3395           if (!sym_exists_at (syms, opdsymend, symcount,
3396                               sym->section->id, sym->value + r->addend))
3397             {
3398               ++count;
3399               size += sizeof (asymbol);
3400               size += strlen (syms[i]->name) + 2;
3401             }
3402         }
3403
3404       if (size == 0)
3405         goto done;
3406       s = *ret = bfd_malloc (size);
3407       if (s == NULL)
3408         {
3409           count = -1;
3410           goto done;
3411         }
3412
3413       names = (char *) (s + count);
3414
3415       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3416         {
3417           asymbol *sym;
3418
3419           while (r < opd->relocation + relcount
3420                  && r->address < syms[i]->value + opd->vma)
3421             ++r;
3422
3423           if (r == opd->relocation + relcount)
3424             break;
3425
3426           if (r->address != syms[i]->value + opd->vma)
3427             continue;
3428
3429           if (r->howto->type != R_PPC64_ADDR64)
3430             continue;
3431
3432           sym = *r->sym_ptr_ptr;
3433           if (!sym_exists_at (syms, opdsymend, symcount,
3434                               sym->section->id, sym->value + r->addend))
3435             {
3436               size_t len;
3437
3438               *s = *syms[i];
3439               s->flags |= BSF_SYNTHETIC;
3440               s->section = sym->section;
3441               s->value = sym->value + r->addend;
3442               s->name = names;
3443               *names++ = '.';
3444               len = strlen (syms[i]->name);
3445               memcpy (names, syms[i]->name, len + 1);
3446               names += len + 1;
3447               /* Have udata.p point back to the original symbol this
3448                  synthetic symbol was derived from.  */
3449               s->udata.p = syms[i];
3450               s++;
3451             }
3452         }
3453     }
3454   else
3455     {
3456       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3457       bfd_byte *contents = NULL;
3458       size_t size;
3459       long plt_count = 0;
3460       bfd_vma glink_vma = 0, resolv_vma = 0;
3461       asection *dynamic, *glink = NULL, *relplt = NULL;
3462       arelent *p;
3463
3464       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3465         {
3466         free_contents_and_exit_err:
3467           count = -1;
3468         free_contents_and_exit:
3469           if (contents)
3470             free (contents);
3471           goto done;
3472         }
3473
3474       size = 0;
3475       for (i = secsymend; i < opdsymend; ++i)
3476         {
3477           bfd_vma ent;
3478
3479           /* Ignore bogus symbols.  */
3480           if (syms[i]->value > opd->size - 8)
3481             continue;
3482
3483           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3484           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3485             {
3486               ++count;
3487               size += sizeof (asymbol);
3488               size += strlen (syms[i]->name) + 2;
3489             }
3490         }
3491
3492       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3493       if (dyn_count != 0
3494           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3495         {
3496           bfd_byte *dynbuf, *extdyn, *extdynend;
3497           size_t extdynsize;
3498           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3499
3500           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3501             goto free_contents_and_exit_err;
3502
3503           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3504           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3505
3506           extdyn = dynbuf;
3507           extdynend = extdyn + dynamic->size;
3508           for (; extdyn < extdynend; extdyn += extdynsize)
3509             {
3510               Elf_Internal_Dyn dyn;
3511               (*swap_dyn_in) (abfd, extdyn, &dyn);
3512
3513               if (dyn.d_tag == DT_NULL)
3514                 break;
3515
3516               if (dyn.d_tag == DT_PPC64_GLINK)
3517                 {
3518                   /* The first glink stub starts at offset 32; see
3519                      comment in ppc64_elf_finish_dynamic_sections. */
3520                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3521                   /* The .glink section usually does not survive the final
3522                      link; search for the section (usually .text) where the
3523                      glink stubs now reside.  */
3524                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3525                                                 &glink_vma);
3526                   break;
3527                 }
3528             }
3529
3530           free (dynbuf);
3531         }
3532
3533       if (glink != NULL)
3534         {
3535           /* Determine __glink trampoline by reading the relative branch
3536              from the first glink stub.  */
3537           bfd_byte buf[4];
3538           unsigned int off = 0;
3539
3540           while (bfd_get_section_contents (abfd, glink, buf,
3541                                            glink_vma + off - glink->vma, 4))
3542             {
3543               unsigned int insn = bfd_get_32 (abfd, buf);
3544               insn ^= B_DOT;
3545               if ((insn & ~0x3fffffc) == 0)
3546                 {
3547                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3548                   break;
3549                 }
3550               off += 4;
3551               if (off > 4)
3552                 break;
3553             }
3554
3555           if (resolv_vma)
3556             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3557
3558           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3559           if (relplt != NULL)
3560             {
3561               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3562               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3563                 goto free_contents_and_exit_err;
3564
3565               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3566               size += plt_count * sizeof (asymbol);
3567
3568               p = relplt->relocation;
3569               for (i = 0; i < plt_count; i++, p++)
3570                 {
3571                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3572                   if (p->addend != 0)
3573                     size += sizeof ("+0x") - 1 + 16;
3574                 }
3575             }
3576         }
3577
3578       if (size == 0)
3579         goto free_contents_and_exit;
3580       s = *ret = bfd_malloc (size);
3581       if (s == NULL)
3582         goto free_contents_and_exit_err;
3583
3584       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3585
3586       for (i = secsymend; i < opdsymend; ++i)
3587         {
3588           bfd_vma ent;
3589
3590           if (syms[i]->value > opd->size - 8)
3591             continue;
3592
3593           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3594           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3595             {
3596               long lo, hi;
3597               size_t len;
3598               asection *sec = abfd->sections;
3599
3600               *s = *syms[i];
3601               lo = codesecsym;
3602               hi = codesecsymend;
3603               while (lo < hi)
3604                 {
3605                   long mid = (lo + hi) >> 1;
3606                   if (syms[mid]->section->vma < ent)
3607                     lo = mid + 1;
3608                   else if (syms[mid]->section->vma > ent)
3609                     hi = mid;
3610                   else
3611                     {
3612                       sec = syms[mid]->section;
3613                       break;
3614                     }
3615                 }
3616
3617               if (lo >= hi && lo > codesecsym)
3618                 sec = syms[lo - 1]->section;
3619
3620               for (; sec != NULL; sec = sec->next)
3621                 {
3622                   if (sec->vma > ent)
3623                     break;
3624                   /* SEC_LOAD may not be set if SEC is from a separate debug
3625                      info file.  */
3626                   if ((sec->flags & SEC_ALLOC) == 0)
3627                     break;
3628                   if ((sec->flags & SEC_CODE) != 0)
3629                     s->section = sec;
3630                 }
3631               s->flags |= BSF_SYNTHETIC;
3632               s->value = ent - s->section->vma;
3633               s->name = names;
3634               *names++ = '.';
3635               len = strlen (syms[i]->name);
3636               memcpy (names, syms[i]->name, len + 1);
3637               names += len + 1;
3638               /* Have udata.p point back to the original symbol this
3639                  synthetic symbol was derived from.  */
3640               s->udata.p = syms[i];
3641               s++;
3642             }
3643         }
3644       free (contents);
3645
3646       if (glink != NULL && relplt != NULL)
3647         {
3648           if (resolv_vma)
3649             {
3650               /* Add a symbol for the main glink trampoline.  */
3651               memset (s, 0, sizeof *s);
3652               s->the_bfd = abfd;
3653               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3654               s->section = glink;
3655               s->value = resolv_vma - glink->vma;
3656               s->name = names;
3657               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3658               names += sizeof ("__glink_PLTresolve");
3659               s++;
3660               count++;
3661             }
3662
3663           /* FIXME: It would be very much nicer to put sym@plt on the
3664              stub rather than on the glink branch table entry.  The
3665              objdump disassembler would then use a sensible symbol
3666              name on plt calls.  The difficulty in doing so is
3667              a) finding the stubs, and,
3668              b) matching stubs against plt entries, and,
3669              c) there can be multiple stubs for a given plt entry.
3670
3671              Solving (a) could be done by code scanning, but older
3672              ppc64 binaries used different stubs to current code.
3673              (b) is the tricky one since you need to known the toc
3674              pointer for at least one function that uses a pic stub to
3675              be able to calculate the plt address referenced.
3676              (c) means gdb would need to set multiple breakpoints (or
3677              find the glink branch itself) when setting breakpoints
3678              for pending shared library loads.  */
3679           p = relplt->relocation;
3680           for (i = 0; i < plt_count; i++, p++)
3681             {
3682               size_t len;
3683
3684               *s = **p->sym_ptr_ptr;
3685               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3686                  we are defining a symbol, ensure one of them is set.  */
3687               if ((s->flags & BSF_LOCAL) == 0)
3688                 s->flags |= BSF_GLOBAL;
3689               s->flags |= BSF_SYNTHETIC;
3690               s->section = glink;
3691               s->value = glink_vma - glink->vma;
3692               s->name = names;
3693               s->udata.p = NULL;
3694               len = strlen ((*p->sym_ptr_ptr)->name);
3695               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3696               names += len;
3697               if (p->addend != 0)
3698                 {
3699                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3700                   names += sizeof ("+0x") - 1;
3701                   bfd_sprintf_vma (abfd, names, p->addend);
3702                   names += strlen (names);
3703                 }
3704               memcpy (names, "@plt", sizeof ("@plt"));
3705               names += sizeof ("@plt");
3706               s++;
3707               if (abi < 2)
3708                 {
3709                   glink_vma += 8;
3710                   if (i >= 0x8000)
3711                     glink_vma += 4;
3712                 }
3713               else
3714                 glink_vma += 4;
3715             }
3716           count += plt_count;
3717         }
3718     }
3719
3720  done:
3721   free (syms);
3722   return count;
3723 }
3724 \f
3725 /* The following functions are specific to the ELF linker, while
3726    functions above are used generally.  Those named ppc64_elf_* are
3727    called by the main ELF linker code.  They appear in this file more
3728    or less in the order in which they are called.  eg.
3729    ppc64_elf_check_relocs is called early in the link process,
3730    ppc64_elf_finish_dynamic_sections is one of the last functions
3731    called.
3732
3733    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3734    functions have both a function code symbol and a function descriptor
3735    symbol.  A call to foo in a relocatable object file looks like:
3736
3737    .            .text
3738    .    x:
3739    .            bl      .foo
3740    .            nop
3741
3742    The function definition in another object file might be:
3743
3744    .            .section .opd
3745    .    foo:    .quad   .foo
3746    .            .quad   .TOC.@tocbase
3747    .            .quad   0
3748    .
3749    .            .text
3750    .    .foo:   blr
3751
3752    When the linker resolves the call during a static link, the branch
3753    unsurprisingly just goes to .foo and the .opd information is unused.
3754    If the function definition is in a shared library, things are a little
3755    different:  The call goes via a plt call stub, the opd information gets
3756    copied to the plt, and the linker patches the nop.
3757
3758    .    x:
3759    .            bl      .foo_stub
3760    .            ld      2,40(1)
3761    .
3762    .
3763    .    .foo_stub:
3764    .            std     2,40(1)                 # in practice, the call stub
3765    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3766    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3767    .            ld      12,0(11)
3768    .            ld      2,8(11)
3769    .            mtctr   12
3770    .            ld      11,16(11)
3771    .            bctr
3772    .
3773    .            .section .plt
3774    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3775
3776    The "reloc ()" notation is supposed to indicate that the linker emits
3777    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3778    copying.
3779
3780    What are the difficulties here?  Well, firstly, the relocations
3781    examined by the linker in check_relocs are against the function code
3782    sym .foo, while the dynamic relocation in the plt is emitted against
3783    the function descriptor symbol, foo.  Somewhere along the line, we need
3784    to carefully copy dynamic link information from one symbol to the other.
3785    Secondly, the generic part of the elf linker will make .foo a dynamic
3786    symbol as is normal for most other backends.  We need foo dynamic
3787    instead, at least for an application final link.  However, when
3788    creating a shared library containing foo, we need to have both symbols
3789    dynamic so that references to .foo are satisfied during the early
3790    stages of linking.  Otherwise the linker might decide to pull in a
3791    definition from some other object, eg. a static library.
3792
3793    Update: As of August 2004, we support a new convention.  Function
3794    calls may use the function descriptor symbol, ie. "bl foo".  This
3795    behaves exactly as "bl .foo".  */
3796
3797 /* Of those relocs that might be copied as dynamic relocs, this
3798    function selects those that must be copied when linking a shared
3799    library or PIE, even when the symbol is local.  */
3800
3801 static int
3802 must_be_dyn_reloc (struct bfd_link_info *info,
3803                    enum elf_ppc64_reloc_type r_type)
3804 {
3805   switch (r_type)
3806     {
3807     default:
3808       /* Only relative relocs can be resolved when the object load
3809          address isn't fixed.  DTPREL64 is excluded because the
3810          dynamic linker needs to differentiate global dynamic from
3811          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3812       return 1;
3813
3814     case R_PPC64_REL32:
3815     case R_PPC64_REL64:
3816     case R_PPC64_REL30:
3817       return 0;
3818
3819     case R_PPC64_TPREL16:
3820     case R_PPC64_TPREL16_LO:
3821     case R_PPC64_TPREL16_HI:
3822     case R_PPC64_TPREL16_HA:
3823     case R_PPC64_TPREL16_DS:
3824     case R_PPC64_TPREL16_LO_DS:
3825     case R_PPC64_TPREL16_HIGH:
3826     case R_PPC64_TPREL16_HIGHA:
3827     case R_PPC64_TPREL16_HIGHER:
3828     case R_PPC64_TPREL16_HIGHERA:
3829     case R_PPC64_TPREL16_HIGHEST:
3830     case R_PPC64_TPREL16_HIGHESTA:
3831     case R_PPC64_TPREL64:
3832       /* These relocations are relative but in a shared library the
3833          linker doesn't know the thread pointer base.  */
3834       return bfd_link_dll (info);
3835     }
3836 }
3837
3838 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3839    copying dynamic variables from a shared lib into an app's dynbss
3840    section, and instead use a dynamic relocation to point into the
3841    shared lib.  With code that gcc generates, it's vital that this be
3842    enabled;  In the PowerPC64 ABI, the address of a function is actually
3843    the address of a function descriptor, which resides in the .opd
3844    section.  gcc uses the descriptor directly rather than going via the
3845    GOT as some other ABI's do, which means that initialized function
3846    pointers must reference the descriptor.  Thus, a function pointer
3847    initialized to the address of a function in a shared library will
3848    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3849    redefines the function descriptor symbol to point to the copy.  This
3850    presents a problem as a plt entry for that function is also
3851    initialized from the function descriptor symbol and the copy reloc
3852    may not be initialized first.  */
3853 #define ELIMINATE_COPY_RELOCS 1
3854
3855 /* Section name for stubs is the associated section name plus this
3856    string.  */
3857 #define STUB_SUFFIX ".stub"
3858
3859 /* Linker stubs.
3860    ppc_stub_long_branch:
3861    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3862    destination, but a 24 bit branch in a stub section will reach.
3863    .    b       dest
3864
3865    ppc_stub_plt_branch:
3866    Similar to the above, but a 24 bit branch in the stub section won't
3867    reach its destination.
3868    .    addis   %r11,%r2,xxx@toc@ha
3869    .    ld      %r12,xxx@toc@l(%r11)
3870    .    mtctr   %r12
3871    .    bctr
3872
3873    ppc_stub_plt_call:
3874    Used to call a function in a shared library.  If it so happens that
3875    the plt entry referenced crosses a 64k boundary, then an extra
3876    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3877    .    std     %r2,40(%r1)
3878    .    addis   %r11,%r2,xxx@toc@ha
3879    .    ld      %r12,xxx+0@toc@l(%r11)
3880    .    mtctr   %r12
3881    .    ld      %r2,xxx+8@toc@l(%r11)
3882    .    ld      %r11,xxx+16@toc@l(%r11)
3883    .    bctr
3884
3885    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3886    code to adjust the value and save r2 to support multiple toc sections.
3887    A ppc_stub_long_branch with an r2 offset looks like:
3888    .    std     %r2,40(%r1)
3889    .    addis   %r2,%r2,off@ha
3890    .    addi    %r2,%r2,off@l
3891    .    b       dest
3892
3893    A ppc_stub_plt_branch with an r2 offset looks like:
3894    .    std     %r2,40(%r1)
3895    .    addis   %r11,%r2,xxx@toc@ha
3896    .    ld      %r12,xxx@toc@l(%r11)
3897    .    addis   %r2,%r2,off@ha
3898    .    addi    %r2,%r2,off@l
3899    .    mtctr   %r12
3900    .    bctr
3901
3902    In cases where the "addis" instruction would add zero, the "addis" is
3903    omitted and following instructions modified slightly in some cases.
3904 */
3905
3906 enum ppc_stub_type {
3907   ppc_stub_none,
3908   ppc_stub_long_branch,
3909   ppc_stub_long_branch_r2off,
3910   ppc_stub_plt_branch,
3911   ppc_stub_plt_branch_r2off,
3912   ppc_stub_plt_call,
3913   ppc_stub_plt_call_r2save,
3914   ppc_stub_global_entry,
3915   ppc_stub_save_res
3916 };
3917
3918 /* Information on stub grouping.  */
3919 struct map_stub
3920 {
3921   /* The stub section.  */
3922   asection *stub_sec;
3923   /* This is the section to which stubs in the group will be attached.  */
3924   asection *link_sec;
3925   /* Next group.  */
3926   struct map_stub *next;
3927   /* Whether to emit a copy of register save/restore functions in this
3928      group.  */
3929   int needs_save_res;
3930   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3931      or -1u if no such stub with bctrl exists.  */
3932   unsigned int tls_get_addr_opt_bctrl;
3933 };
3934
3935 struct ppc_stub_hash_entry {
3936
3937   /* Base hash table entry structure.  */
3938   struct bfd_hash_entry root;
3939
3940   enum ppc_stub_type stub_type;
3941
3942   /* Group information.  */
3943   struct map_stub *group;
3944
3945   /* Offset within stub_sec of the beginning of this stub.  */
3946   bfd_vma stub_offset;
3947
3948   /* Given the symbol's value and its section we can determine its final
3949      value when building the stubs (so the stub knows where to jump.  */
3950   bfd_vma target_value;
3951   asection *target_section;
3952
3953   /* The symbol table entry, if any, that this was derived from.  */
3954   struct ppc_link_hash_entry *h;
3955   struct plt_entry *plt_ent;
3956
3957   /* Symbol st_other.  */
3958   unsigned char other;
3959 };
3960
3961 struct ppc_branch_hash_entry {
3962
3963   /* Base hash table entry structure.  */
3964   struct bfd_hash_entry root;
3965
3966   /* Offset within branch lookup table.  */
3967   unsigned int offset;
3968
3969   /* Generation marker.  */
3970   unsigned int iter;
3971 };
3972
3973 /* Used to track dynamic relocations for local symbols.  */
3974 struct ppc_dyn_relocs
3975 {
3976   struct ppc_dyn_relocs *next;
3977
3978   /* The input section of the reloc.  */
3979   asection *sec;
3980
3981   /* Total number of relocs copied for the input section.  */
3982   unsigned int count : 31;
3983
3984   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3985   unsigned int ifunc : 1;
3986 };
3987
3988 struct ppc_link_hash_entry
3989 {
3990   struct elf_link_hash_entry elf;
3991
3992   union {
3993     /* A pointer to the most recently used stub hash entry against this
3994        symbol.  */
3995     struct ppc_stub_hash_entry *stub_cache;
3996
3997     /* A pointer to the next symbol starting with a '.'  */
3998     struct ppc_link_hash_entry *next_dot_sym;
3999   } u;
4000
4001   /* Track dynamic relocs copied for this symbol.  */
4002   struct elf_dyn_relocs *dyn_relocs;
4003
4004   /* Link between function code and descriptor symbols.  */
4005   struct ppc_link_hash_entry *oh;
4006
4007   /* Flag function code and descriptor symbols.  */
4008   unsigned int is_func:1;
4009   unsigned int is_func_descriptor:1;
4010   unsigned int fake:1;
4011
4012   /* Whether global opd/toc sym has been adjusted or not.
4013      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4014      should be set for all globals defined in any opd/toc section.  */
4015   unsigned int adjust_done:1;
4016
4017   /* Set if this is an out-of-line register save/restore function,
4018      with non-standard calling convention.  */
4019   unsigned int save_res:1;
4020
4021   /* Set if a duplicate symbol with non-zero localentry is detected,
4022      even when the duplicate symbol does not provide a definition.  */
4023   unsigned int non_zero_localentry:1;
4024
4025   /* Contexts in which symbol is used in the GOT (or TOC).
4026      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4027      corresponding relocs are encountered during check_relocs.
4028      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4029      indicate the corresponding GOT entry type is not needed.
4030      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4031      a TPREL one.  We use a separate flag rather than setting TPREL
4032      just for convenience in distinguishing the two cases.  */
4033 #define TLS_GD           1      /* GD reloc. */
4034 #define TLS_LD           2      /* LD reloc. */
4035 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4036 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4037 #define TLS_TLS         16      /* Any TLS reloc.  */
4038 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4039 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4040 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4041   unsigned char tls_mask;
4042 };
4043
4044 /* ppc64 ELF linker hash table.  */
4045
4046 struct ppc_link_hash_table
4047 {
4048   struct elf_link_hash_table elf;
4049
4050   /* The stub hash table.  */
4051   struct bfd_hash_table stub_hash_table;
4052
4053   /* Another hash table for plt_branch stubs.  */
4054   struct bfd_hash_table branch_hash_table;
4055
4056   /* Hash table for function prologue tocsave.  */
4057   htab_t tocsave_htab;
4058
4059   /* Various options and other info passed from the linker.  */
4060   struct ppc64_elf_params *params;
4061
4062   /* The size of sec_info below.  */
4063   unsigned int sec_info_arr_size;
4064
4065   /* Per-section array of extra section info.  Done this way rather
4066      than as part of ppc64_elf_section_data so we have the info for
4067      non-ppc64 sections.  */
4068   struct
4069   {
4070     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4071     bfd_vma toc_off;
4072
4073     union
4074     {
4075       /* The section group that this section belongs to.  */
4076       struct map_stub *group;
4077       /* A temp section list pointer.  */
4078       asection *list;
4079     } u;
4080   } *sec_info;
4081
4082   /* Linked list of groups.  */
4083   struct map_stub *group;
4084
4085   /* Temp used when calculating TOC pointers.  */
4086   bfd_vma toc_curr;
4087   bfd *toc_bfd;
4088   asection *toc_first_sec;
4089
4090   /* Used when adding symbols.  */
4091   struct ppc_link_hash_entry *dot_syms;
4092
4093   /* Shortcuts to get to dynamic linker sections.  */
4094   asection *glink;
4095   asection *sfpr;
4096   asection *brlt;
4097   asection *relbrlt;
4098   asection *glink_eh_frame;
4099
4100   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4101   struct ppc_link_hash_entry *tls_get_addr;
4102   struct ppc_link_hash_entry *tls_get_addr_fd;
4103
4104   /* The size of reliplt used by got entry relocs.  */
4105   bfd_size_type got_reli_size;
4106
4107   /* Statistics.  */
4108   unsigned long stub_count[ppc_stub_global_entry];
4109
4110   /* Number of stubs against global syms.  */
4111   unsigned long stub_globals;
4112
4113   /* Set if we're linking code with function descriptors.  */
4114   unsigned int opd_abi:1;
4115
4116   /* Support for multiple toc sections.  */
4117   unsigned int do_multi_toc:1;
4118   unsigned int multi_toc_needed:1;
4119   unsigned int second_toc_pass:1;
4120   unsigned int do_toc_opt:1;
4121
4122   /* Set if tls optimization is enabled.  */
4123   unsigned int do_tls_opt:1;
4124
4125   /* Set on error.  */
4126   unsigned int stub_error:1;
4127
4128   /* Whether func_desc_adjust needs to be run over symbols.  */
4129   unsigned int need_func_desc_adj:1;
4130
4131   /* Whether there exist local gnu indirect function resolvers,
4132      referenced by dynamic relocations.  */
4133   unsigned int local_ifunc_resolver:1;
4134   unsigned int maybe_local_ifunc_resolver:1;
4135
4136   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4137   unsigned int has_plt_localentry0:1;
4138
4139   /* Incremented every time we size stubs.  */
4140   unsigned int stub_iteration;
4141
4142   /* Small local sym cache.  */
4143   struct sym_cache sym_cache;
4144 };
4145
4146 /* Rename some of the generic section flags to better document how they
4147    are used here.  */
4148
4149 /* Nonzero if this section has TLS related relocations.  */
4150 #define has_tls_reloc sec_flg0
4151
4152 /* Nonzero if this section has a call to __tls_get_addr.  */
4153 #define has_tls_get_addr_call sec_flg1
4154
4155 /* Nonzero if this section has any toc or got relocs.  */
4156 #define has_toc_reloc sec_flg2
4157
4158 /* Nonzero if this section has a call to another section that uses
4159    the toc or got.  */
4160 #define makes_toc_func_call sec_flg3
4161
4162 /* Recursion protection when determining above flag.  */
4163 #define call_check_in_progress sec_flg4
4164 #define call_check_done sec_flg5
4165
4166 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4167
4168 #define ppc_hash_table(p) \
4169   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4170   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4171
4172 #define ppc_stub_hash_lookup(table, string, create, copy) \
4173   ((struct ppc_stub_hash_entry *) \
4174    bfd_hash_lookup ((table), (string), (create), (copy)))
4175
4176 #define ppc_branch_hash_lookup(table, string, create, copy) \
4177   ((struct ppc_branch_hash_entry *) \
4178    bfd_hash_lookup ((table), (string), (create), (copy)))
4179
4180 /* Create an entry in the stub hash table.  */
4181
4182 static struct bfd_hash_entry *
4183 stub_hash_newfunc (struct bfd_hash_entry *entry,
4184                    struct bfd_hash_table *table,
4185                    const char *string)
4186 {
4187   /* Allocate the structure if it has not already been allocated by a
4188      subclass.  */
4189   if (entry == NULL)
4190     {
4191       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4192       if (entry == NULL)
4193         return entry;
4194     }
4195
4196   /* Call the allocation method of the superclass.  */
4197   entry = bfd_hash_newfunc (entry, table, string);
4198   if (entry != NULL)
4199     {
4200       struct ppc_stub_hash_entry *eh;
4201
4202       /* Initialize the local fields.  */
4203       eh = (struct ppc_stub_hash_entry *) entry;
4204       eh->stub_type = ppc_stub_none;
4205       eh->group = NULL;
4206       eh->stub_offset = 0;
4207       eh->target_value = 0;
4208       eh->target_section = NULL;
4209       eh->h = NULL;
4210       eh->plt_ent = NULL;
4211       eh->other = 0;
4212     }
4213
4214   return entry;
4215 }
4216
4217 /* Create an entry in the branch hash table.  */
4218
4219 static struct bfd_hash_entry *
4220 branch_hash_newfunc (struct bfd_hash_entry *entry,
4221                      struct bfd_hash_table *table,
4222                      const char *string)
4223 {
4224   /* Allocate the structure if it has not already been allocated by a
4225      subclass.  */
4226   if (entry == NULL)
4227     {
4228       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4229       if (entry == NULL)
4230         return entry;
4231     }
4232
4233   /* Call the allocation method of the superclass.  */
4234   entry = bfd_hash_newfunc (entry, table, string);
4235   if (entry != NULL)
4236     {
4237       struct ppc_branch_hash_entry *eh;
4238
4239       /* Initialize the local fields.  */
4240       eh = (struct ppc_branch_hash_entry *) entry;
4241       eh->offset = 0;
4242       eh->iter = 0;
4243     }
4244
4245   return entry;
4246 }
4247
4248 /* Create an entry in a ppc64 ELF linker hash table.  */
4249
4250 static struct bfd_hash_entry *
4251 link_hash_newfunc (struct bfd_hash_entry *entry,
4252                    struct bfd_hash_table *table,
4253                    const char *string)
4254 {
4255   /* Allocate the structure if it has not already been allocated by a
4256      subclass.  */
4257   if (entry == NULL)
4258     {
4259       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4260       if (entry == NULL)
4261         return entry;
4262     }
4263
4264   /* Call the allocation method of the superclass.  */
4265   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4266   if (entry != NULL)
4267     {
4268       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4269
4270       memset (&eh->u.stub_cache, 0,
4271               (sizeof (struct ppc_link_hash_entry)
4272                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4273
4274       /* When making function calls, old ABI code references function entry
4275          points (dot symbols), while new ABI code references the function
4276          descriptor symbol.  We need to make any combination of reference and
4277          definition work together, without breaking archive linking.
4278
4279          For a defined function "foo" and an undefined call to "bar":
4280          An old object defines "foo" and ".foo", references ".bar" (possibly
4281          "bar" too).
4282          A new object defines "foo" and references "bar".
4283
4284          A new object thus has no problem with its undefined symbols being
4285          satisfied by definitions in an old object.  On the other hand, the
4286          old object won't have ".bar" satisfied by a new object.
4287
4288          Keep a list of newly added dot-symbols.  */
4289
4290       if (string[0] == '.')
4291         {
4292           struct ppc_link_hash_table *htab;
4293
4294           htab = (struct ppc_link_hash_table *) table;
4295           eh->u.next_dot_sym = htab->dot_syms;
4296           htab->dot_syms = eh;
4297         }
4298     }
4299
4300   return entry;
4301 }
4302
4303 struct tocsave_entry {
4304   asection *sec;
4305   bfd_vma offset;
4306 };
4307
4308 static hashval_t
4309 tocsave_htab_hash (const void *p)
4310 {
4311   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4312   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4313 }
4314
4315 static int
4316 tocsave_htab_eq (const void *p1, const void *p2)
4317 {
4318   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4319   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4320   return e1->sec == e2->sec && e1->offset == e2->offset;
4321 }
4322
4323 /* Destroy a ppc64 ELF linker hash table.  */
4324
4325 static void
4326 ppc64_elf_link_hash_table_free (bfd *obfd)
4327 {
4328   struct ppc_link_hash_table *htab;
4329
4330   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4331   if (htab->tocsave_htab)
4332     htab_delete (htab->tocsave_htab);
4333   bfd_hash_table_free (&htab->branch_hash_table);
4334   bfd_hash_table_free (&htab->stub_hash_table);
4335   _bfd_elf_link_hash_table_free (obfd);
4336 }
4337
4338 /* Create a ppc64 ELF linker hash table.  */
4339
4340 static struct bfd_link_hash_table *
4341 ppc64_elf_link_hash_table_create (bfd *abfd)
4342 {
4343   struct ppc_link_hash_table *htab;
4344   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4345
4346   htab = bfd_zmalloc (amt);
4347   if (htab == NULL)
4348     return NULL;
4349
4350   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4351                                       sizeof (struct ppc_link_hash_entry),
4352                                       PPC64_ELF_DATA))
4353     {
4354       free (htab);
4355       return NULL;
4356     }
4357
4358   /* Init the stub hash table too.  */
4359   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4360                             sizeof (struct ppc_stub_hash_entry)))
4361     {
4362       _bfd_elf_link_hash_table_free (abfd);
4363       return NULL;
4364     }
4365
4366   /* And the branch hash table.  */
4367   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4368                             sizeof (struct ppc_branch_hash_entry)))
4369     {
4370       bfd_hash_table_free (&htab->stub_hash_table);
4371       _bfd_elf_link_hash_table_free (abfd);
4372       return NULL;
4373     }
4374
4375   htab->tocsave_htab = htab_try_create (1024,
4376                                         tocsave_htab_hash,
4377                                         tocsave_htab_eq,
4378                                         NULL);
4379   if (htab->tocsave_htab == NULL)
4380     {
4381       ppc64_elf_link_hash_table_free (abfd);
4382       return NULL;
4383     }
4384   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4385
4386   /* Initializing two fields of the union is just cosmetic.  We really
4387      only care about glist, but when compiled on a 32-bit host the
4388      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4389      debugger inspection of these fields look nicer.  */
4390   htab->elf.init_got_refcount.refcount = 0;
4391   htab->elf.init_got_refcount.glist = NULL;
4392   htab->elf.init_plt_refcount.refcount = 0;
4393   htab->elf.init_plt_refcount.glist = NULL;
4394   htab->elf.init_got_offset.offset = 0;
4395   htab->elf.init_got_offset.glist = NULL;
4396   htab->elf.init_plt_offset.offset = 0;
4397   htab->elf.init_plt_offset.glist = NULL;
4398
4399   return &htab->elf.root;
4400 }
4401
4402 /* Create sections for linker generated code.  */
4403
4404 static bfd_boolean
4405 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4406 {
4407   struct ppc_link_hash_table *htab;
4408   flagword flags;
4409
4410   htab = ppc_hash_table (info);
4411
4412   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4413            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4414   if (htab->params->save_restore_funcs)
4415     {
4416       /* Create .sfpr for code to save and restore fp regs.  */
4417       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4418                                                        flags);
4419       if (htab->sfpr == NULL
4420           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4421         return FALSE;
4422     }
4423
4424   if (bfd_link_relocatable (info))
4425     return TRUE;
4426
4427   /* Create .glink for lazy dynamic linking support.  */
4428   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4429                                                     flags);
4430   if (htab->glink == NULL
4431       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4432     return FALSE;
4433
4434   if (!info->no_ld_generated_unwind_info)
4435     {
4436       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4437                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4438       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4439                                                                  ".eh_frame",
4440                                                                  flags);
4441       if (htab->glink_eh_frame == NULL
4442           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4443         return FALSE;
4444     }
4445
4446   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4447   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4448   if (htab->elf.iplt == NULL
4449       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4450     return FALSE;
4451
4452   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4453            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4454   htab->elf.irelplt
4455     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4456   if (htab->elf.irelplt == NULL
4457       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4458     return FALSE;
4459
4460   /* Create branch lookup table for plt_branch stubs.  */
4461   flags = (SEC_ALLOC | SEC_LOAD
4462            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4463   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4464                                                    flags);
4465   if (htab->brlt == NULL
4466       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4467     return FALSE;
4468
4469   if (!bfd_link_pic (info))
4470     return TRUE;
4471
4472   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4473            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4474   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4475                                                       ".rela.branch_lt",
4476                                                       flags);
4477   if (htab->relbrlt == NULL
4478       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4479     return FALSE;
4480
4481   return TRUE;
4482 }
4483
4484 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4485
4486 bfd_boolean
4487 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4488                          struct ppc64_elf_params *params)
4489 {
4490   struct ppc_link_hash_table *htab;
4491
4492   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4493
4494 /* Always hook our dynamic sections into the first bfd, which is the
4495    linker created stub bfd.  This ensures that the GOT header is at
4496    the start of the output TOC section.  */
4497   htab = ppc_hash_table (info);
4498   htab->elf.dynobj = params->stub_bfd;
4499   htab->params = params;
4500
4501   return create_linkage_sections (htab->elf.dynobj, info);
4502 }
4503
4504 /* Build a name for an entry in the stub hash table.  */
4505
4506 static char *
4507 ppc_stub_name (const asection *input_section,
4508                const asection *sym_sec,
4509                const struct ppc_link_hash_entry *h,
4510                const Elf_Internal_Rela *rel)
4511 {
4512   char *stub_name;
4513   ssize_t len;
4514
4515   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4516      offsets from a sym as a branch target?  In fact, we could
4517      probably assume the addend is always zero.  */
4518   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4519
4520   if (h)
4521     {
4522       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4523       stub_name = bfd_malloc (len);
4524       if (stub_name == NULL)
4525         return stub_name;
4526
4527       len = sprintf (stub_name, "%08x.%s+%x",
4528                      input_section->id & 0xffffffff,
4529                      h->elf.root.root.string,
4530                      (int) rel->r_addend & 0xffffffff);
4531     }
4532   else
4533     {
4534       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4535       stub_name = bfd_malloc (len);
4536       if (stub_name == NULL)
4537         return stub_name;
4538
4539       len = sprintf (stub_name, "%08x.%x:%x+%x",
4540                      input_section->id & 0xffffffff,
4541                      sym_sec->id & 0xffffffff,
4542                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4543                      (int) rel->r_addend & 0xffffffff);
4544     }
4545   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4546     stub_name[len - 2] = 0;
4547   return stub_name;
4548 }
4549
4550 /* Look up an entry in the stub hash.  Stub entries are cached because
4551    creating the stub name takes a bit of time.  */
4552
4553 static struct ppc_stub_hash_entry *
4554 ppc_get_stub_entry (const asection *input_section,
4555                     const asection *sym_sec,
4556                     struct ppc_link_hash_entry *h,
4557                     const Elf_Internal_Rela *rel,
4558                     struct ppc_link_hash_table *htab)
4559 {
4560   struct ppc_stub_hash_entry *stub_entry;
4561   struct map_stub *group;
4562
4563   /* If this input section is part of a group of sections sharing one
4564      stub section, then use the id of the first section in the group.
4565      Stub names need to include a section id, as there may well be
4566      more than one stub used to reach say, printf, and we need to
4567      distinguish between them.  */
4568   group = htab->sec_info[input_section->id].u.group;
4569   if (group == NULL)
4570     return NULL;
4571
4572   if (h != NULL && h->u.stub_cache != NULL
4573       && h->u.stub_cache->h == h
4574       && h->u.stub_cache->group == group)
4575     {
4576       stub_entry = h->u.stub_cache;
4577     }
4578   else
4579     {
4580       char *stub_name;
4581
4582       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4583       if (stub_name == NULL)
4584         return NULL;
4585
4586       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4587                                          stub_name, FALSE, FALSE);
4588       if (h != NULL)
4589         h->u.stub_cache = stub_entry;
4590
4591       free (stub_name);
4592     }
4593
4594   return stub_entry;
4595 }
4596
4597 /* Add a new stub entry to the stub hash.  Not all fields of the new
4598    stub entry are initialised.  */
4599
4600 static struct ppc_stub_hash_entry *
4601 ppc_add_stub (const char *stub_name,
4602               asection *section,
4603               struct bfd_link_info *info)
4604 {
4605   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4606   struct map_stub *group;
4607   asection *link_sec;
4608   asection *stub_sec;
4609   struct ppc_stub_hash_entry *stub_entry;
4610
4611   group = htab->sec_info[section->id].u.group;
4612   link_sec = group->link_sec;
4613   stub_sec = group->stub_sec;
4614   if (stub_sec == NULL)
4615     {
4616       size_t namelen;
4617       bfd_size_type len;
4618       char *s_name;
4619
4620       namelen = strlen (link_sec->name);
4621       len = namelen + sizeof (STUB_SUFFIX);
4622       s_name = bfd_alloc (htab->params->stub_bfd, len);
4623       if (s_name == NULL)
4624         return NULL;
4625
4626       memcpy (s_name, link_sec->name, namelen);
4627       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4628       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4629       if (stub_sec == NULL)
4630         return NULL;
4631       group->stub_sec = stub_sec;
4632     }
4633
4634   /* Enter this entry into the linker stub hash table.  */
4635   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4636                                      TRUE, FALSE);
4637   if (stub_entry == NULL)
4638     {
4639       /* xgettext:c-format */
4640       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4641                               section->owner, stub_name);
4642       return NULL;
4643     }
4644
4645   stub_entry->group = group;
4646   stub_entry->stub_offset = 0;
4647   return stub_entry;
4648 }
4649
4650 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4651    not already done.  */
4652
4653 static bfd_boolean
4654 create_got_section (bfd *abfd, struct bfd_link_info *info)
4655 {
4656   asection *got, *relgot;
4657   flagword flags;
4658   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4659
4660   if (!is_ppc64_elf (abfd))
4661     return FALSE;
4662   if (htab == NULL)
4663     return FALSE;
4664
4665   if (!htab->elf.sgot
4666       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4667     return FALSE;
4668
4669   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4670            | SEC_LINKER_CREATED);
4671
4672   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4673   if (!got
4674       || !bfd_set_section_alignment (abfd, got, 3))
4675     return FALSE;
4676
4677   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4678                                                flags | SEC_READONLY);
4679   if (!relgot
4680       || ! bfd_set_section_alignment (abfd, relgot, 3))
4681     return FALSE;
4682
4683   ppc64_elf_tdata (abfd)->got = got;
4684   ppc64_elf_tdata (abfd)->relgot = relgot;
4685   return TRUE;
4686 }
4687
4688 /* Follow indirect and warning symbol links.  */
4689
4690 static inline struct bfd_link_hash_entry *
4691 follow_link (struct bfd_link_hash_entry *h)
4692 {
4693   while (h->type == bfd_link_hash_indirect
4694          || h->type == bfd_link_hash_warning)
4695     h = h->u.i.link;
4696   return h;
4697 }
4698
4699 static inline struct elf_link_hash_entry *
4700 elf_follow_link (struct elf_link_hash_entry *h)
4701 {
4702   return (struct elf_link_hash_entry *) follow_link (&h->root);
4703 }
4704
4705 static inline struct ppc_link_hash_entry *
4706 ppc_follow_link (struct ppc_link_hash_entry *h)
4707 {
4708   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4709 }
4710
4711 /* Merge PLT info on FROM with that on TO.  */
4712
4713 static void
4714 move_plt_plist (struct ppc_link_hash_entry *from,
4715                 struct ppc_link_hash_entry *to)
4716 {
4717   if (from->elf.plt.plist != NULL)
4718     {
4719       if (to->elf.plt.plist != NULL)
4720         {
4721           struct plt_entry **entp;
4722           struct plt_entry *ent;
4723
4724           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4725             {
4726               struct plt_entry *dent;
4727
4728               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4729                 if (dent->addend == ent->addend)
4730                   {
4731                     dent->plt.refcount += ent->plt.refcount;
4732                     *entp = ent->next;
4733                     break;
4734                   }
4735               if (dent == NULL)
4736                 entp = &ent->next;
4737             }
4738           *entp = to->elf.plt.plist;
4739         }
4740
4741       to->elf.plt.plist = from->elf.plt.plist;
4742       from->elf.plt.plist = NULL;
4743     }
4744 }
4745
4746 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4747
4748 static void
4749 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4750                                 struct elf_link_hash_entry *dir,
4751                                 struct elf_link_hash_entry *ind)
4752 {
4753   struct ppc_link_hash_entry *edir, *eind;
4754
4755   edir = (struct ppc_link_hash_entry *) dir;
4756   eind = (struct ppc_link_hash_entry *) ind;
4757
4758   edir->is_func |= eind->is_func;
4759   edir->is_func_descriptor |= eind->is_func_descriptor;
4760   edir->tls_mask |= eind->tls_mask;
4761   if (eind->oh != NULL)
4762     edir->oh = ppc_follow_link (eind->oh);
4763
4764   /* If called to transfer flags for a weakdef during processing
4765      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4766      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4767   if (!(ELIMINATE_COPY_RELOCS
4768         && eind->elf.root.type != bfd_link_hash_indirect
4769         && edir->elf.dynamic_adjusted))
4770     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4771
4772   if (edir->elf.versioned != versioned_hidden)
4773     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4774   edir->elf.ref_regular |= eind->elf.ref_regular;
4775   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4776   edir->elf.needs_plt |= eind->elf.needs_plt;
4777   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4778
4779   /* If we were called to copy over info for a weak sym, don't copy
4780      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4781      in order to simplify readonly_dynrelocs and save a field in the
4782      symbol hash entry, but that means dyn_relocs can't be used in any
4783      tests about a specific symbol, or affect other symbol flags which
4784      are then tested.  */
4785   if (eind->elf.root.type != bfd_link_hash_indirect)
4786     return;
4787
4788   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4789   if (eind->dyn_relocs != NULL)
4790     {
4791       if (edir->dyn_relocs != NULL)
4792         {
4793           struct elf_dyn_relocs **pp;
4794           struct elf_dyn_relocs *p;
4795
4796           /* Add reloc counts against the indirect sym to the direct sym
4797              list.  Merge any entries against the same section.  */
4798           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4799             {
4800               struct elf_dyn_relocs *q;
4801
4802               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4803                 if (q->sec == p->sec)
4804                   {
4805                     q->pc_count += p->pc_count;
4806                     q->count += p->count;
4807                     *pp = p->next;
4808                     break;
4809                   }
4810               if (q == NULL)
4811                 pp = &p->next;
4812             }
4813           *pp = edir->dyn_relocs;
4814         }
4815
4816       edir->dyn_relocs = eind->dyn_relocs;
4817       eind->dyn_relocs = NULL;
4818     }
4819
4820   /* Copy over got entries that we may have already seen to the
4821      symbol which just became indirect.  */
4822   if (eind->elf.got.glist != NULL)
4823     {
4824       if (edir->elf.got.glist != NULL)
4825         {
4826           struct got_entry **entp;
4827           struct got_entry *ent;
4828
4829           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4830             {
4831               struct got_entry *dent;
4832
4833               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4834                 if (dent->addend == ent->addend
4835                     && dent->owner == ent->owner
4836                     && dent->tls_type == ent->tls_type)
4837                   {
4838                     dent->got.refcount += ent->got.refcount;
4839                     *entp = ent->next;
4840                     break;
4841                   }
4842               if (dent == NULL)
4843                 entp = &ent->next;
4844             }
4845           *entp = edir->elf.got.glist;
4846         }
4847
4848       edir->elf.got.glist = eind->elf.got.glist;
4849       eind->elf.got.glist = NULL;
4850     }
4851
4852   /* And plt entries.  */
4853   move_plt_plist (eind, edir);
4854
4855   if (eind->elf.dynindx != -1)
4856     {
4857       if (edir->elf.dynindx != -1)
4858         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4859                                 edir->elf.dynstr_index);
4860       edir->elf.dynindx = eind->elf.dynindx;
4861       edir->elf.dynstr_index = eind->elf.dynstr_index;
4862       eind->elf.dynindx = -1;
4863       eind->elf.dynstr_index = 0;
4864     }
4865 }
4866
4867 /* Find the function descriptor hash entry from the given function code
4868    hash entry FH.  Link the entries via their OH fields.  */
4869
4870 static struct ppc_link_hash_entry *
4871 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4872 {
4873   struct ppc_link_hash_entry *fdh = fh->oh;
4874
4875   if (fdh == NULL)
4876     {
4877       const char *fd_name = fh->elf.root.root.string + 1;
4878
4879       fdh = (struct ppc_link_hash_entry *)
4880         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4881       if (fdh == NULL)
4882         return fdh;
4883
4884       fdh->is_func_descriptor = 1;
4885       fdh->oh = fh;
4886       fh->is_func = 1;
4887       fh->oh = fdh;
4888     }
4889
4890   fdh = ppc_follow_link (fdh);
4891   fdh->is_func_descriptor = 1;
4892   fdh->oh = fh;
4893   return fdh;
4894 }
4895
4896 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4897
4898 static struct ppc_link_hash_entry *
4899 make_fdh (struct bfd_link_info *info,
4900           struct ppc_link_hash_entry *fh)
4901 {
4902   bfd *abfd = fh->elf.root.u.undef.abfd;
4903   struct bfd_link_hash_entry *bh = NULL;
4904   struct ppc_link_hash_entry *fdh;
4905   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4906                     ? BSF_WEAK
4907                     : BSF_GLOBAL);
4908
4909   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4910                                          fh->elf.root.root.string + 1,
4911                                          flags, bfd_und_section_ptr, 0,
4912                                          NULL, FALSE, FALSE, &bh))
4913     return NULL;
4914
4915   fdh = (struct ppc_link_hash_entry *) bh;
4916   fdh->elf.non_elf = 0;
4917   fdh->fake = 1;
4918   fdh->is_func_descriptor = 1;
4919   fdh->oh = fh;
4920   fh->is_func = 1;
4921   fh->oh = fdh;
4922   return fdh;
4923 }
4924
4925 /* Fix function descriptor symbols defined in .opd sections to be
4926    function type.  */
4927
4928 static bfd_boolean
4929 ppc64_elf_add_symbol_hook (bfd *ibfd,
4930                            struct bfd_link_info *info,
4931                            Elf_Internal_Sym *isym,
4932                            const char **name,
4933                            flagword *flags ATTRIBUTE_UNUSED,
4934                            asection **sec,
4935                            bfd_vma *value)
4936 {
4937   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4938       && (ibfd->flags & DYNAMIC) == 0
4939       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4940     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4941
4942   if (*sec != NULL
4943       && strcmp ((*sec)->name, ".opd") == 0)
4944     {
4945       asection *code_sec;
4946
4947       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4948             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4949         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4950
4951       /* If the symbol is a function defined in .opd, and the function
4952          code is in a discarded group, let it appear to be undefined.  */
4953       if (!bfd_link_relocatable (info)
4954           && (*sec)->reloc_count != 0
4955           && opd_entry_value (*sec, *value, &code_sec, NULL,
4956                               FALSE) != (bfd_vma) -1
4957           && discarded_section (code_sec))
4958         {
4959           *sec = bfd_und_section_ptr;
4960           isym->st_shndx = SHN_UNDEF;
4961         }
4962     }
4963   else if (*sec != NULL
4964            && strcmp ((*sec)->name, ".toc") == 0
4965            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4966     {
4967       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4968       if (htab != NULL)
4969         htab->params->object_in_toc = 1;
4970     }
4971
4972   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4973     {
4974       if (abiversion (ibfd) == 0)
4975         set_abiversion (ibfd, 2);
4976       else if (abiversion (ibfd) == 1)
4977         {
4978           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4979                                     " for ABI version 1\n"), name);
4980           bfd_set_error (bfd_error_bad_value);
4981           return FALSE;
4982         }
4983     }
4984
4985   return TRUE;
4986 }
4987
4988 /* Merge non-visibility st_other attributes: local entry point.  */
4989
4990 static void
4991 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4992                                   const Elf_Internal_Sym *isym,
4993                                   bfd_boolean definition,
4994                                   bfd_boolean dynamic)
4995 {
4996   if (definition && (!dynamic || !h->def_regular))
4997     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4998                 | ELF_ST_VISIBILITY (h->other));
4999 }
5000
5001 /* Hook called on merging a symbol.  We use this to clear "fake" since
5002    we now have a real symbol.  */
5003
5004 static bfd_boolean
5005 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5006                         const Elf_Internal_Sym *isym,
5007                         asection **psec ATTRIBUTE_UNUSED,
5008                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5009                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5010                         bfd *oldbfd ATTRIBUTE_UNUSED,
5011                         const asection *oldsec ATTRIBUTE_UNUSED)
5012 {
5013   ((struct ppc_link_hash_entry *) h)->fake = 0;
5014   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5015     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5016   return TRUE;
5017 }
5018
5019 /* This function makes an old ABI object reference to ".bar" cause the
5020    inclusion of a new ABI object archive that defines "bar".
5021    NAME is a symbol defined in an archive.  Return a symbol in the hash
5022    table that might be satisfied by the archive symbols.  */
5023
5024 static struct elf_link_hash_entry *
5025 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5026                                  struct bfd_link_info *info,
5027                                  const char *name)
5028 {
5029   struct elf_link_hash_entry *h;
5030   char *dot_name;
5031   size_t len;
5032
5033   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5034   if (h != NULL
5035       /* Don't return this sym if it is a fake function descriptor
5036          created by add_symbol_adjust.  */
5037       && !((struct ppc_link_hash_entry *) h)->fake)
5038     return h;
5039
5040   if (name[0] == '.')
5041     return h;
5042
5043   len = strlen (name);
5044   dot_name = bfd_alloc (abfd, len + 2);
5045   if (dot_name == NULL)
5046     return (struct elf_link_hash_entry *) 0 - 1;
5047   dot_name[0] = '.';
5048   memcpy (dot_name + 1, name, len + 1);
5049   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5050   bfd_release (abfd, dot_name);
5051   return h;
5052 }
5053
5054 /* This function satisfies all old ABI object references to ".bar" if a
5055    new ABI object defines "bar".  Well, at least, undefined dot symbols
5056    are made weak.  This stops later archive searches from including an
5057    object if we already have a function descriptor definition.  It also
5058    prevents the linker complaining about undefined symbols.
5059    We also check and correct mismatched symbol visibility here.  The
5060    most restrictive visibility of the function descriptor and the
5061    function entry symbol is used.  */
5062
5063 static bfd_boolean
5064 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5065 {
5066   struct ppc_link_hash_table *htab;
5067   struct ppc_link_hash_entry *fdh;
5068
5069   if (eh->elf.root.type == bfd_link_hash_warning)
5070     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5071
5072   if (eh->elf.root.type == bfd_link_hash_indirect)
5073     return TRUE;
5074
5075   if (eh->elf.root.root.string[0] != '.')
5076     abort ();
5077
5078   htab = ppc_hash_table (info);
5079   if (htab == NULL)
5080     return FALSE;
5081
5082   fdh = lookup_fdh (eh, htab);
5083   if (fdh == NULL
5084       && !bfd_link_relocatable (info)
5085       && (eh->elf.root.type == bfd_link_hash_undefined
5086           || eh->elf.root.type == bfd_link_hash_undefweak)
5087       && eh->elf.ref_regular)
5088     {
5089       /* Make an undefined function descriptor sym, in order to
5090          pull in an --as-needed shared lib.  Archives are handled
5091          elsewhere.  */
5092       fdh = make_fdh (info, eh);
5093       if (fdh == NULL)
5094         return FALSE;
5095     }
5096
5097   if (fdh != NULL)
5098     {
5099       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5100       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5101
5102       /* Make both descriptor and entry symbol have the most
5103          constraining visibility of either symbol.  */
5104       if (entry_vis < descr_vis)
5105         fdh->elf.other += entry_vis - descr_vis;
5106       else if (entry_vis > descr_vis)
5107         eh->elf.other += descr_vis - entry_vis;
5108
5109       /* Propagate reference flags from entry symbol to function
5110          descriptor symbol.  */
5111       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5112       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5113       fdh->elf.ref_regular |= eh->elf.ref_regular;
5114       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5115
5116       if (!fdh->elf.forced_local
5117           && fdh->elf.dynindx == -1
5118           && fdh->elf.versioned != versioned_hidden
5119           && (bfd_link_dll (info)
5120               || fdh->elf.def_dynamic
5121               || fdh->elf.ref_dynamic)
5122           && (eh->elf.ref_regular
5123               || eh->elf.def_regular))
5124         {
5125           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5126             return FALSE;
5127         }
5128     }
5129
5130   return TRUE;
5131 }
5132
5133 /* Set up opd section info and abiversion for IBFD, and process list
5134    of dot-symbols we made in link_hash_newfunc.  */
5135
5136 static bfd_boolean
5137 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5138 {
5139   struct ppc_link_hash_table *htab;
5140   struct ppc_link_hash_entry **p, *eh;
5141   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5142
5143   if (opd != NULL && opd->size != 0)
5144     {
5145       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5146       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5147
5148       if (abiversion (ibfd) == 0)
5149         set_abiversion (ibfd, 1);
5150       else if (abiversion (ibfd) >= 2)
5151         {
5152           /* xgettext:c-format */
5153           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5154                                     " version %d\n"),
5155                                   ibfd, abiversion (ibfd));
5156           bfd_set_error (bfd_error_bad_value);
5157           return FALSE;
5158         }
5159     }
5160
5161   if (is_ppc64_elf (info->output_bfd))
5162     {
5163       /* For input files without an explicit abiversion in e_flags
5164          we should have flagged any with symbol st_other bits set
5165          as ELFv1 and above flagged those with .opd as ELFv2.
5166          Set the output abiversion if not yet set, and for any input
5167          still ambiguous, take its abiversion from the output.
5168          Differences in ABI are reported later.  */
5169       if (abiversion (info->output_bfd) == 0)
5170         set_abiversion (info->output_bfd, abiversion (ibfd));
5171       else if (abiversion (ibfd) == 0)
5172         set_abiversion (ibfd, abiversion (info->output_bfd));
5173     }
5174
5175   htab = ppc_hash_table (info);
5176   if (htab == NULL)
5177     return TRUE;
5178
5179   if (opd != NULL && opd->size != 0
5180       && (ibfd->flags & DYNAMIC) == 0
5181       && (opd->flags & SEC_RELOC) != 0
5182       && opd->reloc_count != 0
5183       && !bfd_is_abs_section (opd->output_section)
5184       && info->gc_sections)
5185     {
5186       /* Garbage collection needs some extra help with .opd sections.
5187          We don't want to necessarily keep everything referenced by
5188          relocs in .opd, as that would keep all functions.  Instead,
5189          if we reference an .opd symbol (a function descriptor), we
5190          want to keep the function code symbol's section.  This is
5191          easy for global symbols, but for local syms we need to keep
5192          information about the associated function section.  */
5193       bfd_size_type amt;
5194       asection **opd_sym_map;
5195       Elf_Internal_Shdr *symtab_hdr;
5196       Elf_Internal_Rela *relocs, *rel_end, *rel;
5197
5198       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5199       opd_sym_map = bfd_zalloc (ibfd, amt);
5200       if (opd_sym_map == NULL)
5201         return FALSE;
5202       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5203       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5204                                           info->keep_memory);
5205       if (relocs == NULL)
5206         return FALSE;
5207       symtab_hdr = &elf_symtab_hdr (ibfd);
5208       rel_end = relocs + opd->reloc_count - 1;
5209       for (rel = relocs; rel < rel_end; rel++)
5210         {
5211           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5212           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5213
5214           if (r_type == R_PPC64_ADDR64
5215               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5216               && r_symndx < symtab_hdr->sh_info)
5217             {
5218               Elf_Internal_Sym *isym;
5219               asection *s;
5220
5221               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5222               if (isym == NULL)
5223                 {
5224                   if (elf_section_data (opd)->relocs != relocs)
5225                     free (relocs);
5226                   return FALSE;
5227                 }
5228
5229               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5230               if (s != NULL && s != opd)
5231                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5232             }
5233         }
5234       if (elf_section_data (opd)->relocs != relocs)
5235         free (relocs);
5236     }
5237
5238   p = &htab->dot_syms;
5239   while ((eh = *p) != NULL)
5240     {
5241       *p = NULL;
5242       if (&eh->elf == htab->elf.hgot)
5243         ;
5244       else if (htab->elf.hgot == NULL
5245                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5246         htab->elf.hgot = &eh->elf;
5247       else if (abiversion (ibfd) <= 1)
5248         {
5249           htab->need_func_desc_adj = 1;
5250           if (!add_symbol_adjust (eh, info))
5251             return FALSE;
5252         }
5253       p = &eh->u.next_dot_sym;
5254     }
5255   return TRUE;
5256 }
5257
5258 /* Undo hash table changes when an --as-needed input file is determined
5259    not to be needed.  */
5260
5261 static bfd_boolean
5262 ppc64_elf_notice_as_needed (bfd *ibfd,
5263                             struct bfd_link_info *info,
5264                             enum notice_asneeded_action act)
5265 {
5266   if (act == notice_not_needed)
5267     {
5268       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5269
5270       if (htab == NULL)
5271         return FALSE;
5272
5273       htab->dot_syms = NULL;
5274     }
5275   return _bfd_elf_notice_as_needed (ibfd, info, act);
5276 }
5277
5278 /* If --just-symbols against a final linked binary, then assume we need
5279    toc adjusting stubs when calling functions defined there.  */
5280
5281 static void
5282 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5283 {
5284   if ((sec->flags & SEC_CODE) != 0
5285       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5286       && is_ppc64_elf (sec->owner))
5287     {
5288       if (abiversion (sec->owner) >= 2
5289           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5290         sec->has_toc_reloc = 1;
5291     }
5292   _bfd_elf_link_just_syms (sec, info);
5293 }
5294
5295 static struct plt_entry **
5296 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5297                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5298 {
5299   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5300   struct plt_entry **local_plt;
5301   unsigned char *local_got_tls_masks;
5302
5303   if (local_got_ents == NULL)
5304     {
5305       bfd_size_type size = symtab_hdr->sh_info;
5306
5307       size *= (sizeof (*local_got_ents)
5308                + sizeof (*local_plt)
5309                + sizeof (*local_got_tls_masks));
5310       local_got_ents = bfd_zalloc (abfd, size);
5311       if (local_got_ents == NULL)
5312         return NULL;
5313       elf_local_got_ents (abfd) = local_got_ents;
5314     }
5315
5316   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5317     {
5318       struct got_entry *ent;
5319
5320       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5321         if (ent->addend == r_addend
5322             && ent->owner == abfd
5323             && ent->tls_type == tls_type)
5324           break;
5325       if (ent == NULL)
5326         {
5327           bfd_size_type amt = sizeof (*ent);
5328           ent = bfd_alloc (abfd, amt);
5329           if (ent == NULL)
5330             return FALSE;
5331           ent->next = local_got_ents[r_symndx];
5332           ent->addend = r_addend;
5333           ent->owner = abfd;
5334           ent->tls_type = tls_type;
5335           ent->is_indirect = FALSE;
5336           ent->got.refcount = 0;
5337           local_got_ents[r_symndx] = ent;
5338         }
5339       ent->got.refcount += 1;
5340     }
5341
5342   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5343   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5344   local_got_tls_masks[r_symndx] |= tls_type;
5345
5346   return local_plt + r_symndx;
5347 }
5348
5349 static bfd_boolean
5350 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5351 {
5352   struct plt_entry *ent;
5353
5354   for (ent = *plist; ent != NULL; ent = ent->next)
5355     if (ent->addend == addend)
5356       break;
5357   if (ent == NULL)
5358     {
5359       bfd_size_type amt = sizeof (*ent);
5360       ent = bfd_alloc (abfd, amt);
5361       if (ent == NULL)
5362         return FALSE;
5363       ent->next = *plist;
5364       ent->addend = addend;
5365       ent->plt.refcount = 0;
5366       *plist = ent;
5367     }
5368   ent->plt.refcount += 1;
5369   return TRUE;
5370 }
5371
5372 static bfd_boolean
5373 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5374 {
5375   return (r_type == R_PPC64_REL24
5376           || r_type == R_PPC64_REL14
5377           || r_type == R_PPC64_REL14_BRTAKEN
5378           || r_type == R_PPC64_REL14_BRNTAKEN
5379           || r_type == R_PPC64_ADDR24
5380           || r_type == R_PPC64_ADDR14
5381           || r_type == R_PPC64_ADDR14_BRTAKEN
5382           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5383 }
5384
5385 /* Look through the relocs for a section during the first phase, and
5386    calculate needed space in the global offset table, procedure
5387    linkage table, and dynamic reloc sections.  */
5388
5389 static bfd_boolean
5390 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5391                         asection *sec, const Elf_Internal_Rela *relocs)
5392 {
5393   struct ppc_link_hash_table *htab;
5394   Elf_Internal_Shdr *symtab_hdr;
5395   struct elf_link_hash_entry **sym_hashes;
5396   const Elf_Internal_Rela *rel;
5397   const Elf_Internal_Rela *rel_end;
5398   asection *sreloc;
5399   struct elf_link_hash_entry *tga, *dottga;
5400   bfd_boolean is_opd;
5401
5402   if (bfd_link_relocatable (info))
5403     return TRUE;
5404
5405   /* Don't do anything special with non-loaded, non-alloced sections.
5406      In particular, any relocs in such sections should not affect GOT
5407      and PLT reference counting (ie. we don't allow them to create GOT
5408      or PLT entries), there's no possibility or desire to optimize TLS
5409      relocs, and there's not much point in propagating relocs to shared
5410      libs that the dynamic linker won't relocate.  */
5411   if ((sec->flags & SEC_ALLOC) == 0)
5412     return TRUE;
5413
5414   BFD_ASSERT (is_ppc64_elf (abfd));
5415
5416   htab = ppc_hash_table (info);
5417   if (htab == NULL)
5418     return FALSE;
5419
5420   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5421                               FALSE, FALSE, TRUE);
5422   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5423                                  FALSE, FALSE, TRUE);
5424   symtab_hdr = &elf_symtab_hdr (abfd);
5425   sym_hashes = elf_sym_hashes (abfd);
5426   sreloc = NULL;
5427   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5428   rel_end = relocs + sec->reloc_count;
5429   for (rel = relocs; rel < rel_end; rel++)
5430     {
5431       unsigned long r_symndx;
5432       struct elf_link_hash_entry *h;
5433       enum elf_ppc64_reloc_type r_type;
5434       int tls_type;
5435       struct _ppc64_elf_section_data *ppc64_sec;
5436       struct plt_entry **ifunc, **plt_list;
5437
5438       r_symndx = ELF64_R_SYM (rel->r_info);
5439       if (r_symndx < symtab_hdr->sh_info)
5440         h = NULL;
5441       else
5442         {
5443           struct ppc_link_hash_entry *eh;
5444
5445           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5446           h = elf_follow_link (h);
5447           eh = (struct ppc_link_hash_entry *) h;
5448
5449           /* PR15323, ref flags aren't set for references in the same
5450              object.  */
5451           h->root.non_ir_ref_regular = 1;
5452           if (eh->is_func && eh->oh != NULL)
5453             eh->oh->elf.root.non_ir_ref_regular = 1;
5454
5455           if (h == htab->elf.hgot)
5456             sec->has_toc_reloc = 1;
5457         }
5458
5459       tls_type = 0;
5460       ifunc = NULL;
5461       if (h != NULL)
5462         {
5463           if (h->type == STT_GNU_IFUNC)
5464             {
5465               h->needs_plt = 1;
5466               ifunc = &h->plt.plist;
5467             }
5468         }
5469       else
5470         {
5471           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5472                                                           abfd, r_symndx);
5473           if (isym == NULL)
5474             return FALSE;
5475
5476           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5477             {
5478               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5479                                              rel->r_addend, PLT_IFUNC);
5480               if (ifunc == NULL)
5481                 return FALSE;
5482             }
5483         }
5484
5485       r_type = ELF64_R_TYPE (rel->r_info);
5486       switch (r_type)
5487         {
5488         case R_PPC64_TLSGD:
5489         case R_PPC64_TLSLD:
5490           /* These special tls relocs tie a call to __tls_get_addr with
5491              its parameter symbol.  */
5492           break;
5493
5494         case R_PPC64_GOT_TLSLD16:
5495         case R_PPC64_GOT_TLSLD16_LO:
5496         case R_PPC64_GOT_TLSLD16_HI:
5497         case R_PPC64_GOT_TLSLD16_HA:
5498           tls_type = TLS_TLS | TLS_LD;
5499           goto dogottls;
5500
5501         case R_PPC64_GOT_TLSGD16:
5502         case R_PPC64_GOT_TLSGD16_LO:
5503         case R_PPC64_GOT_TLSGD16_HI:
5504         case R_PPC64_GOT_TLSGD16_HA:
5505           tls_type = TLS_TLS | TLS_GD;
5506           goto dogottls;
5507
5508         case R_PPC64_GOT_TPREL16_DS:
5509         case R_PPC64_GOT_TPREL16_LO_DS:
5510         case R_PPC64_GOT_TPREL16_HI:
5511         case R_PPC64_GOT_TPREL16_HA:
5512           if (bfd_link_dll (info))
5513             info->flags |= DF_STATIC_TLS;
5514           tls_type = TLS_TLS | TLS_TPREL;
5515           goto dogottls;
5516
5517         case R_PPC64_GOT_DTPREL16_DS:
5518         case R_PPC64_GOT_DTPREL16_LO_DS:
5519         case R_PPC64_GOT_DTPREL16_HI:
5520         case R_PPC64_GOT_DTPREL16_HA:
5521           tls_type = TLS_TLS | TLS_DTPREL;
5522         dogottls:
5523           sec->has_tls_reloc = 1;
5524           /* Fall through */
5525
5526         case R_PPC64_GOT16:
5527         case R_PPC64_GOT16_DS:
5528         case R_PPC64_GOT16_HA:
5529         case R_PPC64_GOT16_HI:
5530         case R_PPC64_GOT16_LO:
5531         case R_PPC64_GOT16_LO_DS:
5532           /* This symbol requires a global offset table entry.  */
5533           sec->has_toc_reloc = 1;
5534           if (r_type == R_PPC64_GOT_TLSLD16
5535               || r_type == R_PPC64_GOT_TLSGD16
5536               || r_type == R_PPC64_GOT_TPREL16_DS
5537               || r_type == R_PPC64_GOT_DTPREL16_DS
5538               || r_type == R_PPC64_GOT16
5539               || r_type == R_PPC64_GOT16_DS)
5540             {
5541               htab->do_multi_toc = 1;
5542               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5543             }
5544
5545           if (ppc64_elf_tdata (abfd)->got == NULL
5546               && !create_got_section (abfd, info))
5547             return FALSE;
5548
5549           if (h != NULL)
5550             {
5551               struct ppc_link_hash_entry *eh;
5552               struct got_entry *ent;
5553
5554               eh = (struct ppc_link_hash_entry *) h;
5555               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5556                 if (ent->addend == rel->r_addend
5557                     && ent->owner == abfd
5558                     && ent->tls_type == tls_type)
5559                   break;
5560               if (ent == NULL)
5561                 {
5562                   bfd_size_type amt = sizeof (*ent);
5563                   ent = bfd_alloc (abfd, amt);
5564                   if (ent == NULL)
5565                     return FALSE;
5566                   ent->next = eh->elf.got.glist;
5567                   ent->addend = rel->r_addend;
5568                   ent->owner = abfd;
5569                   ent->tls_type = tls_type;
5570                   ent->is_indirect = FALSE;
5571                   ent->got.refcount = 0;
5572                   eh->elf.got.glist = ent;
5573                 }
5574               ent->got.refcount += 1;
5575               eh->tls_mask |= tls_type;
5576             }
5577           else
5578             /* This is a global offset table entry for a local symbol.  */
5579             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5580                                         rel->r_addend, tls_type))
5581               return FALSE;
5582
5583           /* We may also need a plt entry if the symbol turns out to be
5584              an ifunc.  */
5585           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5586             {
5587               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5588                 return FALSE;
5589             }
5590           break;
5591
5592         case R_PPC64_PLT16_HA:
5593         case R_PPC64_PLT16_HI:
5594         case R_PPC64_PLT16_LO:
5595         case R_PPC64_PLT32:
5596         case R_PPC64_PLT64:
5597           /* This symbol requires a procedure linkage table entry.  */
5598           plt_list = ifunc;
5599           if (h != NULL)
5600             {
5601               h->needs_plt = 1;
5602               if (h->root.root.string[0] == '.'
5603                   && h->root.root.string[1] != '\0')
5604                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5605               plt_list = &h->plt.plist;
5606             }
5607           if (plt_list == NULL)
5608             {
5609               /* It does not make sense to have a procedure linkage
5610                  table entry for a non-ifunc local symbol.  */
5611               info->callbacks->einfo
5612                 /* xgettext:c-format */
5613                 (_("%H: %s reloc against local symbol\n"),
5614                  abfd, sec, rel->r_offset,
5615                  ppc64_elf_howto_table[r_type]->name);
5616               bfd_set_error (bfd_error_bad_value);
5617               return FALSE;
5618             }
5619           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5620             return FALSE;
5621           break;
5622
5623           /* The following relocations don't need to propagate the
5624              relocation if linking a shared object since they are
5625              section relative.  */
5626         case R_PPC64_SECTOFF:
5627         case R_PPC64_SECTOFF_LO:
5628         case R_PPC64_SECTOFF_HI:
5629         case R_PPC64_SECTOFF_HA:
5630         case R_PPC64_SECTOFF_DS:
5631         case R_PPC64_SECTOFF_LO_DS:
5632         case R_PPC64_DTPREL16:
5633         case R_PPC64_DTPREL16_LO:
5634         case R_PPC64_DTPREL16_HI:
5635         case R_PPC64_DTPREL16_HA:
5636         case R_PPC64_DTPREL16_DS:
5637         case R_PPC64_DTPREL16_LO_DS:
5638         case R_PPC64_DTPREL16_HIGH:
5639         case R_PPC64_DTPREL16_HIGHA:
5640         case R_PPC64_DTPREL16_HIGHER:
5641         case R_PPC64_DTPREL16_HIGHERA:
5642         case R_PPC64_DTPREL16_HIGHEST:
5643         case R_PPC64_DTPREL16_HIGHESTA:
5644           break;
5645
5646           /* Nor do these.  */
5647         case R_PPC64_REL16:
5648         case R_PPC64_REL16_LO:
5649         case R_PPC64_REL16_HI:
5650         case R_PPC64_REL16_HA:
5651         case R_PPC64_REL16DX_HA:
5652           break;
5653
5654           /* Not supported as a dynamic relocation.  */
5655         case R_PPC64_ADDR64_LOCAL:
5656           if (bfd_link_pic (info))
5657             {
5658               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5659                 ppc_howto_init ();
5660               /* xgettext:c-format */
5661               info->callbacks->einfo (_("%H: %s reloc unsupported "
5662                                         "in shared libraries and PIEs.\n"),
5663                                       abfd, sec, rel->r_offset,
5664                                       ppc64_elf_howto_table[r_type]->name);
5665               bfd_set_error (bfd_error_bad_value);
5666               return FALSE;
5667             }
5668           break;
5669
5670         case R_PPC64_TOC16:
5671         case R_PPC64_TOC16_DS:
5672           htab->do_multi_toc = 1;
5673           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5674           /* Fall through.  */
5675         case R_PPC64_TOC16_LO:
5676         case R_PPC64_TOC16_HI:
5677         case R_PPC64_TOC16_HA:
5678         case R_PPC64_TOC16_LO_DS:
5679           sec->has_toc_reloc = 1;
5680           break;
5681
5682           /* Marker reloc.  */
5683         case R_PPC64_ENTRY:
5684           break;
5685
5686           /* This relocation describes the C++ object vtable hierarchy.
5687              Reconstruct it for later use during GC.  */
5688         case R_PPC64_GNU_VTINHERIT:
5689           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5690             return FALSE;
5691           break;
5692
5693           /* This relocation describes which C++ vtable entries are actually
5694              used.  Record for later use during GC.  */
5695         case R_PPC64_GNU_VTENTRY:
5696           BFD_ASSERT (h != NULL);
5697           if (h != NULL
5698               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5699             return FALSE;
5700           break;
5701
5702         case R_PPC64_REL14:
5703         case R_PPC64_REL14_BRTAKEN:
5704         case R_PPC64_REL14_BRNTAKEN:
5705           {
5706             asection *dest = NULL;
5707
5708             /* Heuristic: If jumping outside our section, chances are
5709                we are going to need a stub.  */
5710             if (h != NULL)
5711               {
5712                 /* If the sym is weak it may be overridden later, so
5713                    don't assume we know where a weak sym lives.  */
5714                 if (h->root.type == bfd_link_hash_defined)
5715                   dest = h->root.u.def.section;
5716               }
5717             else
5718               {
5719                 Elf_Internal_Sym *isym;
5720
5721                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5722                                               abfd, r_symndx);
5723                 if (isym == NULL)
5724                   return FALSE;
5725
5726                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5727               }
5728
5729             if (dest != sec)
5730               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5731           }
5732           /* Fall through.  */
5733
5734         case R_PPC64_REL24:
5735           plt_list = ifunc;
5736           if (h != NULL)
5737             {
5738               h->needs_plt = 1;
5739               if (h->root.root.string[0] == '.'
5740                   && h->root.root.string[1] != '\0')
5741                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5742
5743               if (h == tga || h == dottga)
5744                 {
5745                   sec->has_tls_reloc = 1;
5746                   if (rel != relocs
5747                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5748                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5749                     /* We have a new-style __tls_get_addr call with
5750                        a marker reloc.  */
5751                     ;
5752                   else
5753                     /* Mark this section as having an old-style call.  */
5754                     sec->has_tls_get_addr_call = 1;
5755                 }
5756               plt_list = &h->plt.plist;
5757             }
5758
5759           /* We may need a .plt entry if the function this reloc
5760              refers to is in a shared lib.  */
5761           if (plt_list
5762               && !update_plt_info (abfd, plt_list, rel->r_addend))
5763             return FALSE;
5764           break;
5765
5766         case R_PPC64_ADDR14:
5767         case R_PPC64_ADDR14_BRNTAKEN:
5768         case R_PPC64_ADDR14_BRTAKEN:
5769         case R_PPC64_ADDR24:
5770           goto dodyn;
5771
5772         case R_PPC64_TPREL64:
5773           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5774           if (bfd_link_dll (info))
5775             info->flags |= DF_STATIC_TLS;
5776           goto dotlstoc;
5777
5778         case R_PPC64_DTPMOD64:
5779           if (rel + 1 < rel_end
5780               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5781               && rel[1].r_offset == rel->r_offset + 8)
5782             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5783           else
5784             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5785           goto dotlstoc;
5786
5787         case R_PPC64_DTPREL64:
5788           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5789           if (rel != relocs
5790               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5791               && rel[-1].r_offset == rel->r_offset - 8)
5792             /* This is the second reloc of a dtpmod, dtprel pair.
5793                Don't mark with TLS_DTPREL.  */
5794             goto dodyn;
5795
5796         dotlstoc:
5797           sec->has_tls_reloc = 1;
5798           if (h != NULL)
5799             {
5800               struct ppc_link_hash_entry *eh;
5801               eh = (struct ppc_link_hash_entry *) h;
5802               eh->tls_mask |= tls_type;
5803             }
5804           else
5805             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5806                                         rel->r_addend, tls_type))
5807               return FALSE;
5808
5809           ppc64_sec = ppc64_elf_section_data (sec);
5810           if (ppc64_sec->sec_type != sec_toc)
5811             {
5812               bfd_size_type amt;
5813
5814               /* One extra to simplify get_tls_mask.  */
5815               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5816               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5817               if (ppc64_sec->u.toc.symndx == NULL)
5818                 return FALSE;
5819               amt = sec->size * sizeof (bfd_vma) / 8;
5820               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5821               if (ppc64_sec->u.toc.add == NULL)
5822                 return FALSE;
5823               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5824               ppc64_sec->sec_type = sec_toc;
5825             }
5826           BFD_ASSERT (rel->r_offset % 8 == 0);
5827           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5828           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5829
5830           /* Mark the second slot of a GD or LD entry.
5831              -1 to indicate GD and -2 to indicate LD.  */
5832           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5833             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5834           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5835             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5836           goto dodyn;
5837
5838         case R_PPC64_TPREL16:
5839         case R_PPC64_TPREL16_LO:
5840         case R_PPC64_TPREL16_HI:
5841         case R_PPC64_TPREL16_HA:
5842         case R_PPC64_TPREL16_DS:
5843         case R_PPC64_TPREL16_LO_DS:
5844         case R_PPC64_TPREL16_HIGH:
5845         case R_PPC64_TPREL16_HIGHA:
5846         case R_PPC64_TPREL16_HIGHER:
5847         case R_PPC64_TPREL16_HIGHERA:
5848         case R_PPC64_TPREL16_HIGHEST:
5849         case R_PPC64_TPREL16_HIGHESTA:
5850           if (bfd_link_dll (info))
5851             info->flags |= DF_STATIC_TLS;
5852           goto dodyn;
5853
5854         case R_PPC64_ADDR64:
5855           if (is_opd
5856               && rel + 1 < rel_end
5857               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5858             {
5859               if (h != NULL)
5860                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5861             }
5862           /* Fall through.  */
5863
5864         case R_PPC64_ADDR16:
5865         case R_PPC64_ADDR16_DS:
5866         case R_PPC64_ADDR16_HA:
5867         case R_PPC64_ADDR16_HI:
5868         case R_PPC64_ADDR16_HIGH:
5869         case R_PPC64_ADDR16_HIGHA:
5870         case R_PPC64_ADDR16_HIGHER:
5871         case R_PPC64_ADDR16_HIGHERA:
5872         case R_PPC64_ADDR16_HIGHEST:
5873         case R_PPC64_ADDR16_HIGHESTA:
5874         case R_PPC64_ADDR16_LO:
5875         case R_PPC64_ADDR16_LO_DS:
5876           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5877               && rel->r_addend == 0)
5878             {
5879               /* We may need a .plt entry if this reloc refers to a
5880                  function in a shared lib.  */
5881               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5882                 return FALSE;
5883               h->pointer_equality_needed = 1;
5884             }
5885           /* Fall through.  */
5886
5887         case R_PPC64_REL30:
5888         case R_PPC64_REL32:
5889         case R_PPC64_REL64:
5890         case R_PPC64_ADDR32:
5891         case R_PPC64_UADDR16:
5892         case R_PPC64_UADDR32:
5893         case R_PPC64_UADDR64:
5894         case R_PPC64_TOC:
5895           if (h != NULL && !bfd_link_pic (info))
5896             /* We may need a copy reloc.  */
5897             h->non_got_ref = 1;
5898
5899           /* Don't propagate .opd relocs.  */
5900           if (NO_OPD_RELOCS && is_opd)
5901             break;
5902
5903           /* If we are creating a shared library, and this is a reloc
5904              against a global symbol, or a non PC relative reloc
5905              against a local symbol, then we need to copy the reloc
5906              into the shared library.  However, if we are linking with
5907              -Bsymbolic, we do not need to copy a reloc against a
5908              global symbol which is defined in an object we are
5909              including in the link (i.e., DEF_REGULAR is set).  At
5910              this point we have not seen all the input files, so it is
5911              possible that DEF_REGULAR is not set now but will be set
5912              later (it is never cleared).  In case of a weak definition,
5913              DEF_REGULAR may be cleared later by a strong definition in
5914              a shared library.  We account for that possibility below by
5915              storing information in the dyn_relocs field of the hash
5916              table entry.  A similar situation occurs when creating
5917              shared libraries and symbol visibility changes render the
5918              symbol local.
5919
5920              If on the other hand, we are creating an executable, we
5921              may need to keep relocations for symbols satisfied by a
5922              dynamic library if we manage to avoid copy relocs for the
5923              symbol.  */
5924         dodyn:
5925           if ((bfd_link_pic (info)
5926                && (must_be_dyn_reloc (info, r_type)
5927                    || (h != NULL
5928                        && (!SYMBOLIC_BIND (info, h)
5929                            || h->root.type == bfd_link_hash_defweak
5930                            || !h->def_regular))))
5931               || (ELIMINATE_COPY_RELOCS
5932                   && !bfd_link_pic (info)
5933                   && h != NULL
5934                   && (h->root.type == bfd_link_hash_defweak
5935                       || !h->def_regular))
5936               || (!bfd_link_pic (info)
5937                   && ifunc != NULL))
5938             {
5939               /* We must copy these reloc types into the output file.
5940                  Create a reloc section in dynobj and make room for
5941                  this reloc.  */
5942               if (sreloc == NULL)
5943                 {
5944                   sreloc = _bfd_elf_make_dynamic_reloc_section
5945                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5946
5947                   if (sreloc == NULL)
5948                     return FALSE;
5949                 }
5950
5951               /* If this is a global symbol, we count the number of
5952                  relocations we need for this symbol.  */
5953               if (h != NULL)
5954                 {
5955                   struct elf_dyn_relocs *p;
5956                   struct elf_dyn_relocs **head;
5957
5958                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5959                   p = *head;
5960                   if (p == NULL || p->sec != sec)
5961                     {
5962                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5963                       if (p == NULL)
5964                         return FALSE;
5965                       p->next = *head;
5966                       *head = p;
5967                       p->sec = sec;
5968                       p->count = 0;
5969                       p->pc_count = 0;
5970                     }
5971                   p->count += 1;
5972                   if (!must_be_dyn_reloc (info, r_type))
5973                     p->pc_count += 1;
5974                 }
5975               else
5976                 {
5977                   /* Track dynamic relocs needed for local syms too.
5978                      We really need local syms available to do this
5979                      easily.  Oh well.  */
5980                   struct ppc_dyn_relocs *p;
5981                   struct ppc_dyn_relocs **head;
5982                   bfd_boolean is_ifunc;
5983                   asection *s;
5984                   void *vpp;
5985                   Elf_Internal_Sym *isym;
5986
5987                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5988                                                 abfd, r_symndx);
5989                   if (isym == NULL)
5990                     return FALSE;
5991
5992                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5993                   if (s == NULL)
5994                     s = sec;
5995
5996                   vpp = &elf_section_data (s)->local_dynrel;
5997                   head = (struct ppc_dyn_relocs **) vpp;
5998                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5999                   p = *head;
6000                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6001                     p = p->next;
6002                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6003                     {
6004                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6005                       if (p == NULL)
6006                         return FALSE;
6007                       p->next = *head;
6008                       *head = p;
6009                       p->sec = sec;
6010                       p->ifunc = is_ifunc;
6011                       p->count = 0;
6012                     }
6013                   p->count += 1;
6014                 }
6015             }
6016           break;
6017
6018         default:
6019           break;
6020         }
6021     }
6022
6023   return TRUE;
6024 }
6025
6026 /* Merge backend specific data from an object file to the output
6027    object file when linking.  */
6028
6029 static bfd_boolean
6030 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6031 {
6032   bfd *obfd = info->output_bfd;
6033   unsigned long iflags, oflags;
6034
6035   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6036     return TRUE;
6037
6038   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6039     return TRUE;
6040
6041   if (!_bfd_generic_verify_endian_match (ibfd, info))
6042     return FALSE;
6043
6044   iflags = elf_elfheader (ibfd)->e_flags;
6045   oflags = elf_elfheader (obfd)->e_flags;
6046
6047   if (iflags & ~EF_PPC64_ABI)
6048     {
6049       _bfd_error_handler
6050         /* xgettext:c-format */
6051         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6052       bfd_set_error (bfd_error_bad_value);
6053       return FALSE;
6054     }
6055   else if (iflags != oflags && iflags != 0)
6056     {
6057       _bfd_error_handler
6058         /* xgettext:c-format */
6059         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6060          ibfd, iflags, oflags);
6061       bfd_set_error (bfd_error_bad_value);
6062       return FALSE;
6063     }
6064
6065   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6066
6067   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6068   _bfd_elf_merge_object_attributes (ibfd, info);
6069
6070   return TRUE;
6071 }
6072
6073 static bfd_boolean
6074 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6075 {
6076   /* Print normal ELF private data.  */
6077   _bfd_elf_print_private_bfd_data (abfd, ptr);
6078
6079   if (elf_elfheader (abfd)->e_flags != 0)
6080     {
6081       FILE *file = ptr;
6082
6083       fprintf (file, _("private flags = 0x%lx:"),
6084                elf_elfheader (abfd)->e_flags);
6085
6086       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6087         fprintf (file, _(" [abiv%ld]"),
6088                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6089       fputc ('\n', file);
6090     }
6091
6092   return TRUE;
6093 }
6094
6095 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6096    of the code entry point, and its section, which must be in the same
6097    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6098
6099 static bfd_vma
6100 opd_entry_value (asection *opd_sec,
6101                  bfd_vma offset,
6102                  asection **code_sec,
6103                  bfd_vma *code_off,
6104                  bfd_boolean in_code_sec)
6105 {
6106   bfd *opd_bfd = opd_sec->owner;
6107   Elf_Internal_Rela *relocs;
6108   Elf_Internal_Rela *lo, *hi, *look;
6109   bfd_vma val;
6110
6111   /* No relocs implies we are linking a --just-symbols object, or looking
6112      at a final linked executable with addr2line or somesuch.  */
6113   if (opd_sec->reloc_count == 0)
6114     {
6115       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6116
6117       if (contents == NULL)
6118         {
6119           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6120             return (bfd_vma) -1;
6121           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6122         }
6123
6124       /* PR 17512: file: 64b9dfbb.  */
6125       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6126         return (bfd_vma) -1;
6127
6128       val = bfd_get_64 (opd_bfd, contents + offset);
6129       if (code_sec != NULL)
6130         {
6131           asection *sec, *likely = NULL;
6132
6133           if (in_code_sec)
6134             {
6135               sec = *code_sec;
6136               if (sec->vma <= val
6137                   && val < sec->vma + sec->size)
6138                 likely = sec;
6139               else
6140                 val = -1;
6141             }
6142           else
6143             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6144               if (sec->vma <= val
6145                   && (sec->flags & SEC_LOAD) != 0
6146                   && (sec->flags & SEC_ALLOC) != 0)
6147                 likely = sec;
6148           if (likely != NULL)
6149             {
6150               *code_sec = likely;
6151               if (code_off != NULL)
6152                 *code_off = val - likely->vma;
6153             }
6154         }
6155       return val;
6156     }
6157
6158   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6159
6160   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6161   if (relocs == NULL)
6162     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6163   /* PR 17512: file: df8e1fd6.  */
6164   if (relocs == NULL)
6165     return (bfd_vma) -1;
6166
6167   /* Go find the opd reloc at the sym address.  */
6168   lo = relocs;
6169   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6170   val = (bfd_vma) -1;
6171   while (lo < hi)
6172     {
6173       look = lo + (hi - lo) / 2;
6174       if (look->r_offset < offset)
6175         lo = look + 1;
6176       else if (look->r_offset > offset)
6177         hi = look;
6178       else
6179         {
6180           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6181
6182           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6183               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6184             {
6185               unsigned long symndx = ELF64_R_SYM (look->r_info);
6186               asection *sec = NULL;
6187
6188               if (symndx >= symtab_hdr->sh_info
6189                   && elf_sym_hashes (opd_bfd) != NULL)
6190                 {
6191                   struct elf_link_hash_entry **sym_hashes;
6192                   struct elf_link_hash_entry *rh;
6193
6194                   sym_hashes = elf_sym_hashes (opd_bfd);
6195                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6196                   if (rh != NULL)
6197                     {
6198                       rh = elf_follow_link (rh);
6199                       if (rh->root.type != bfd_link_hash_defined
6200                           && rh->root.type != bfd_link_hash_defweak)
6201                         break;
6202                       if (rh->root.u.def.section->owner == opd_bfd)
6203                         {
6204                           val = rh->root.u.def.value;
6205                           sec = rh->root.u.def.section;
6206                         }
6207                     }
6208                 }
6209
6210               if (sec == NULL)
6211                 {
6212                   Elf_Internal_Sym *sym;
6213
6214                   if (symndx < symtab_hdr->sh_info)
6215                     {
6216                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6217                       if (sym == NULL)
6218                         {
6219                           size_t symcnt = symtab_hdr->sh_info;
6220                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6221                                                       symcnt, 0,
6222                                                       NULL, NULL, NULL);
6223                           if (sym == NULL)
6224                             break;
6225                           symtab_hdr->contents = (bfd_byte *) sym;
6226                         }
6227                       sym += symndx;
6228                     }
6229                   else
6230                     {
6231                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6232                                                   1, symndx,
6233                                                   NULL, NULL, NULL);
6234                       if (sym == NULL)
6235                         break;
6236                     }
6237                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6238                   if (sec == NULL)
6239                     break;
6240                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6241                   val = sym->st_value;
6242                 }
6243
6244               val += look->r_addend;
6245               if (code_off != NULL)
6246                 *code_off = val;
6247               if (code_sec != NULL)
6248                 {
6249                   if (in_code_sec && *code_sec != sec)
6250                     return -1;
6251                   else
6252                     *code_sec = sec;
6253                 }
6254               if (sec->output_section != NULL)
6255                 val += sec->output_section->vma + sec->output_offset;
6256             }
6257           break;
6258         }
6259     }
6260
6261   return val;
6262 }
6263
6264 /* If the ELF symbol SYM might be a function in SEC, return the
6265    function size and set *CODE_OFF to the function's entry point,
6266    otherwise return zero.  */
6267
6268 static bfd_size_type
6269 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6270                               bfd_vma *code_off)
6271 {
6272   bfd_size_type size;
6273
6274   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6275                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6276     return 0;
6277
6278   size = 0;
6279   if (!(sym->flags & BSF_SYNTHETIC))
6280     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6281
6282   if (strcmp (sym->section->name, ".opd") == 0)
6283     {
6284       struct _opd_sec_data *opd = get_opd_info (sym->section);
6285       bfd_vma symval = sym->value;
6286
6287       if (opd != NULL
6288           && opd->adjust != NULL
6289           && elf_section_data (sym->section)->relocs != NULL)
6290         {
6291           /* opd_entry_value will use cached relocs that have been
6292              adjusted, but with raw symbols.  That means both local
6293              and global symbols need adjusting.  */
6294           long adjust = opd->adjust[OPD_NDX (symval)];
6295           if (adjust == -1)
6296             return 0;
6297           symval += adjust;
6298         }
6299
6300       if (opd_entry_value (sym->section, symval,
6301                            &sec, code_off, TRUE) == (bfd_vma) -1)
6302         return 0;
6303       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6304          symbol.  This size has nothing to do with the code size of the
6305          function, which is what we're supposed to return, but the
6306          code size isn't available without looking up the dot-sym.
6307          However, doing that would be a waste of time particularly
6308          since elf_find_function will look at the dot-sym anyway.
6309          Now, elf_find_function will keep the largest size of any
6310          function sym found at the code address of interest, so return
6311          1 here to avoid it incorrectly caching a larger function size
6312          for a small function.  This does mean we return the wrong
6313          size for a new-ABI function of size 24, but all that does is
6314          disable caching for such functions.  */
6315       if (size == 24)
6316         size = 1;
6317     }
6318   else
6319     {
6320       if (sym->section != sec)
6321         return 0;
6322       *code_off = sym->value;
6323     }
6324   if (size == 0)
6325     size = 1;
6326   return size;
6327 }
6328
6329 /* Return true if symbol is a strong function defined in an ELFv2
6330    object with st_other localentry bits of zero, ie. its local entry
6331    point coincides with its global entry point.  */
6332
6333 static bfd_boolean
6334 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6335 {
6336   return (h != NULL
6337           && h->type == STT_FUNC
6338           && h->root.type == bfd_link_hash_defined
6339           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6340           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6341           && is_ppc64_elf (h->root.u.def.section->owner)
6342           && abiversion (h->root.u.def.section->owner) >= 2);
6343 }
6344
6345 /* Return true if symbol is defined in a regular object file.  */
6346
6347 static bfd_boolean
6348 is_static_defined (struct elf_link_hash_entry *h)
6349 {
6350   return ((h->root.type == bfd_link_hash_defined
6351            || h->root.type == bfd_link_hash_defweak)
6352           && h->root.u.def.section != NULL
6353           && h->root.u.def.section->output_section != NULL);
6354 }
6355
6356 /* If FDH is a function descriptor symbol, return the associated code
6357    entry symbol if it is defined.  Return NULL otherwise.  */
6358
6359 static struct ppc_link_hash_entry *
6360 defined_code_entry (struct ppc_link_hash_entry *fdh)
6361 {
6362   if (fdh->is_func_descriptor)
6363     {
6364       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6365       if (fh->elf.root.type == bfd_link_hash_defined
6366           || fh->elf.root.type == bfd_link_hash_defweak)
6367         return fh;
6368     }
6369   return NULL;
6370 }
6371
6372 /* If FH is a function code entry symbol, return the associated
6373    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6374
6375 static struct ppc_link_hash_entry *
6376 defined_func_desc (struct ppc_link_hash_entry *fh)
6377 {
6378   if (fh->oh != NULL
6379       && fh->oh->is_func_descriptor)
6380     {
6381       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6382       if (fdh->elf.root.type == bfd_link_hash_defined
6383           || fdh->elf.root.type == bfd_link_hash_defweak)
6384         return fdh;
6385     }
6386   return NULL;
6387 }
6388
6389 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6390
6391 /* Garbage collect sections, after first dealing with dot-symbols.  */
6392
6393 static bfd_boolean
6394 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6395 {
6396   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6397
6398   if (htab != NULL && htab->need_func_desc_adj)
6399     {
6400       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6401       htab->need_func_desc_adj = 0;
6402     }
6403   return bfd_elf_gc_sections (abfd, info);
6404 }
6405
6406 /* Mark all our entry sym sections, both opd and code section.  */
6407
6408 static void
6409 ppc64_elf_gc_keep (struct bfd_link_info *info)
6410 {
6411   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6412   struct bfd_sym_chain *sym;
6413
6414   if (htab == NULL)
6415     return;
6416
6417   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6418     {
6419       struct ppc_link_hash_entry *eh, *fh;
6420       asection *sec;
6421
6422       eh = (struct ppc_link_hash_entry *)
6423         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6424       if (eh == NULL)
6425         continue;
6426       if (eh->elf.root.type != bfd_link_hash_defined
6427           && eh->elf.root.type != bfd_link_hash_defweak)
6428         continue;
6429
6430       fh = defined_code_entry (eh);
6431       if (fh != NULL)
6432         {
6433           sec = fh->elf.root.u.def.section;
6434           sec->flags |= SEC_KEEP;
6435         }
6436       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6437                && opd_entry_value (eh->elf.root.u.def.section,
6438                                    eh->elf.root.u.def.value,
6439                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6440         sec->flags |= SEC_KEEP;
6441
6442       sec = eh->elf.root.u.def.section;
6443       sec->flags |= SEC_KEEP;
6444     }
6445 }
6446
6447 /* Mark sections containing dynamically referenced symbols.  When
6448    building shared libraries, we must assume that any visible symbol is
6449    referenced.  */
6450
6451 static bfd_boolean
6452 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6453 {
6454   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6455   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6456   struct ppc_link_hash_entry *fdh;
6457   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6458
6459   /* Dynamic linking info is on the func descriptor sym.  */
6460   fdh = defined_func_desc (eh);
6461   if (fdh != NULL)
6462     eh = fdh;
6463
6464   if ((eh->elf.root.type == bfd_link_hash_defined
6465        || eh->elf.root.type == bfd_link_hash_defweak)
6466       && (eh->elf.ref_dynamic
6467           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6468               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6469               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6470               && (!bfd_link_executable (info)
6471                   || info->gc_keep_exported
6472                   || info->export_dynamic
6473                   || (eh->elf.dynamic
6474                       && d != NULL
6475                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6476               && (eh->elf.versioned >= versioned
6477                   || !bfd_hide_sym_by_version (info->version_info,
6478                                                eh->elf.root.root.string)))))
6479     {
6480       asection *code_sec;
6481       struct ppc_link_hash_entry *fh;
6482
6483       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6484
6485       /* Function descriptor syms cause the associated
6486          function code sym section to be marked.  */
6487       fh = defined_code_entry (eh);
6488       if (fh != NULL)
6489         {
6490           code_sec = fh->elf.root.u.def.section;
6491           code_sec->flags |= SEC_KEEP;
6492         }
6493       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6494                && opd_entry_value (eh->elf.root.u.def.section,
6495                                    eh->elf.root.u.def.value,
6496                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6497         code_sec->flags |= SEC_KEEP;
6498     }
6499
6500   return TRUE;
6501 }
6502
6503 /* Return the section that should be marked against GC for a given
6504    relocation.  */
6505
6506 static asection *
6507 ppc64_elf_gc_mark_hook (asection *sec,
6508                         struct bfd_link_info *info,
6509                         Elf_Internal_Rela *rel,
6510                         struct elf_link_hash_entry *h,
6511                         Elf_Internal_Sym *sym)
6512 {
6513   asection *rsec;
6514
6515   /* Syms return NULL if we're marking .opd, so we avoid marking all
6516      function sections, as all functions are referenced in .opd.  */
6517   rsec = NULL;
6518   if (get_opd_info (sec) != NULL)
6519     return rsec;
6520
6521   if (h != NULL)
6522     {
6523       enum elf_ppc64_reloc_type r_type;
6524       struct ppc_link_hash_entry *eh, *fh, *fdh;
6525
6526       r_type = ELF64_R_TYPE (rel->r_info);
6527       switch (r_type)
6528         {
6529         case R_PPC64_GNU_VTINHERIT:
6530         case R_PPC64_GNU_VTENTRY:
6531           break;
6532
6533         default:
6534           switch (h->root.type)
6535             {
6536             case bfd_link_hash_defined:
6537             case bfd_link_hash_defweak:
6538               eh = (struct ppc_link_hash_entry *) h;
6539               fdh = defined_func_desc (eh);
6540               if (fdh != NULL)
6541                 {
6542                   /* -mcall-aixdesc code references the dot-symbol on
6543                      a call reloc.  Mark the function descriptor too
6544                      against garbage collection.  */
6545                   fdh->elf.mark = 1;
6546                   if (fdh->elf.is_weakalias)
6547                     weakdef (&fdh->elf)->mark = 1;
6548                   eh = fdh;
6549                 }
6550
6551               /* Function descriptor syms cause the associated
6552                  function code sym section to be marked.  */
6553               fh = defined_code_entry (eh);
6554               if (fh != NULL)
6555                 {
6556                   /* They also mark their opd section.  */
6557                   eh->elf.root.u.def.section->gc_mark = 1;
6558
6559                   rsec = fh->elf.root.u.def.section;
6560                 }
6561               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6562                        && opd_entry_value (eh->elf.root.u.def.section,
6563                                            eh->elf.root.u.def.value,
6564                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6565                 eh->elf.root.u.def.section->gc_mark = 1;
6566               else
6567                 rsec = h->root.u.def.section;
6568               break;
6569
6570             case bfd_link_hash_common:
6571               rsec = h->root.u.c.p->section;
6572               break;
6573
6574             default:
6575               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6576             }
6577         }
6578     }
6579   else
6580     {
6581       struct _opd_sec_data *opd;
6582
6583       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6584       opd = get_opd_info (rsec);
6585       if (opd != NULL && opd->func_sec != NULL)
6586         {
6587           rsec->gc_mark = 1;
6588
6589           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6590         }
6591     }
6592
6593   return rsec;
6594 }
6595
6596 /* The maximum size of .sfpr.  */
6597 #define SFPR_MAX (218*4)
6598
6599 struct sfpr_def_parms
6600 {
6601   const char name[12];
6602   unsigned char lo, hi;
6603   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6604   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6605 };
6606
6607 /* Auto-generate _save*, _rest* functions in .sfpr.
6608    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6609    instead.  */
6610
6611 static bfd_boolean
6612 sfpr_define (struct bfd_link_info *info,
6613              const struct sfpr_def_parms *parm,
6614              asection *stub_sec)
6615 {
6616   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6617   unsigned int i;
6618   size_t len = strlen (parm->name);
6619   bfd_boolean writing = FALSE;
6620   char sym[16];
6621
6622   if (htab == NULL)
6623     return FALSE;
6624
6625   memcpy (sym, parm->name, len);
6626   sym[len + 2] = 0;
6627
6628   for (i = parm->lo; i <= parm->hi; i++)
6629     {
6630       struct ppc_link_hash_entry *h;
6631
6632       sym[len + 0] = i / 10 + '0';
6633       sym[len + 1] = i % 10 + '0';
6634       h = (struct ppc_link_hash_entry *)
6635         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6636       if (stub_sec != NULL)
6637         {
6638           if (h != NULL
6639               && h->elf.root.type == bfd_link_hash_defined
6640               && h->elf.root.u.def.section == htab->sfpr)
6641             {
6642               struct elf_link_hash_entry *s;
6643               char buf[32];
6644               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6645               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6646               if (s == NULL)
6647                 return FALSE;
6648               if (s->root.type == bfd_link_hash_new
6649                   || (s->root.type = bfd_link_hash_defined
6650                       && s->root.u.def.section == stub_sec))
6651                 {
6652                   s->root.type = bfd_link_hash_defined;
6653                   s->root.u.def.section = stub_sec;
6654                   s->root.u.def.value = (stub_sec->size
6655                                          + h->elf.root.u.def.value);
6656                   s->ref_regular = 1;
6657                   s->def_regular = 1;
6658                   s->ref_regular_nonweak = 1;
6659                   s->forced_local = 1;
6660                   s->non_elf = 0;
6661                   s->root.linker_def = 1;
6662                 }
6663             }
6664           continue;
6665         }
6666       if (h != NULL)
6667         {
6668           h->save_res = 1;
6669           if (!h->elf.def_regular)
6670             {
6671               h->elf.root.type = bfd_link_hash_defined;
6672               h->elf.root.u.def.section = htab->sfpr;
6673               h->elf.root.u.def.value = htab->sfpr->size;
6674               h->elf.type = STT_FUNC;
6675               h->elf.def_regular = 1;
6676               h->elf.non_elf = 0;
6677               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6678               writing = TRUE;
6679               if (htab->sfpr->contents == NULL)
6680                 {
6681                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6682                   if (htab->sfpr->contents == NULL)
6683                     return FALSE;
6684                 }
6685             }
6686         }
6687       if (writing)
6688         {
6689           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6690           if (i != parm->hi)
6691             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6692           else
6693             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6694           htab->sfpr->size = p - htab->sfpr->contents;
6695         }
6696     }
6697
6698   return TRUE;
6699 }
6700
6701 static bfd_byte *
6702 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6703 {
6704   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6705   return p + 4;
6706 }
6707
6708 static bfd_byte *
6709 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6710 {
6711   p = savegpr0 (abfd, p, r);
6712   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6713   p = p + 4;
6714   bfd_put_32 (abfd, BLR, p);
6715   return p + 4;
6716 }
6717
6718 static bfd_byte *
6719 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6720 {
6721   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6722   return p + 4;
6723 }
6724
6725 static bfd_byte *
6726 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6727 {
6728   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6729   p = p + 4;
6730   p = restgpr0 (abfd, p, r);
6731   bfd_put_32 (abfd, MTLR_R0, p);
6732   p = p + 4;
6733   if (r == 29)
6734     {
6735       p = restgpr0 (abfd, p, 30);
6736       p = restgpr0 (abfd, p, 31);
6737     }
6738   bfd_put_32 (abfd, BLR, p);
6739   return p + 4;
6740 }
6741
6742 static bfd_byte *
6743 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6744 {
6745   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6746   return p + 4;
6747 }
6748
6749 static bfd_byte *
6750 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6751 {
6752   p = savegpr1 (abfd, p, r);
6753   bfd_put_32 (abfd, BLR, p);
6754   return p + 4;
6755 }
6756
6757 static bfd_byte *
6758 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6759 {
6760   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6761   return p + 4;
6762 }
6763
6764 static bfd_byte *
6765 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6766 {
6767   p = restgpr1 (abfd, p, r);
6768   bfd_put_32 (abfd, BLR, p);
6769   return p + 4;
6770 }
6771
6772 static bfd_byte *
6773 savefpr (bfd *abfd, bfd_byte *p, int r)
6774 {
6775   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6776   return p + 4;
6777 }
6778
6779 static bfd_byte *
6780 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6781 {
6782   p = savefpr (abfd, p, r);
6783   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6784   p = p + 4;
6785   bfd_put_32 (abfd, BLR, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 restfpr (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6793   return p + 4;
6794 }
6795
6796 static bfd_byte *
6797 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6798 {
6799   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6800   p = p + 4;
6801   p = restfpr (abfd, p, r);
6802   bfd_put_32 (abfd, MTLR_R0, p);
6803   p = p + 4;
6804   if (r == 29)
6805     {
6806       p = restfpr (abfd, p, 30);
6807       p = restfpr (abfd, p, 31);
6808     }
6809   bfd_put_32 (abfd, BLR, p);
6810   return p + 4;
6811 }
6812
6813 static bfd_byte *
6814 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6815 {
6816   p = savefpr (abfd, p, r);
6817   bfd_put_32 (abfd, BLR, p);
6818   return p + 4;
6819 }
6820
6821 static bfd_byte *
6822 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6823 {
6824   p = restfpr (abfd, p, r);
6825   bfd_put_32 (abfd, BLR, p);
6826   return p + 4;
6827 }
6828
6829 static bfd_byte *
6830 savevr (bfd *abfd, bfd_byte *p, int r)
6831 {
6832   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6833   p = p + 4;
6834   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6835   return p + 4;
6836 }
6837
6838 static bfd_byte *
6839 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6840 {
6841   p = savevr (abfd, p, r);
6842   bfd_put_32 (abfd, BLR, p);
6843   return p + 4;
6844 }
6845
6846 static bfd_byte *
6847 restvr (bfd *abfd, bfd_byte *p, int r)
6848 {
6849   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6850   p = p + 4;
6851   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6852   return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6857 {
6858   p = restvr (abfd, p, r);
6859   bfd_put_32 (abfd, BLR, p);
6860   return p + 4;
6861 }
6862
6863 /* Called via elf_link_hash_traverse to transfer dynamic linking
6864    information on function code symbol entries to their corresponding
6865    function descriptor symbol entries.  */
6866
6867 static bfd_boolean
6868 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6869 {
6870   struct bfd_link_info *info;
6871   struct ppc_link_hash_table *htab;
6872   struct ppc_link_hash_entry *fh;
6873   struct ppc_link_hash_entry *fdh;
6874   bfd_boolean force_local;
6875
6876   fh = (struct ppc_link_hash_entry *) h;
6877   if (fh->elf.root.type == bfd_link_hash_indirect)
6878     return TRUE;
6879
6880   if (!fh->is_func)
6881     return TRUE;
6882
6883   if (fh->elf.root.root.string[0] != '.'
6884       || fh->elf.root.root.string[1] == '\0')
6885     return TRUE;
6886
6887   info = inf;
6888   htab = ppc_hash_table (info);
6889   if (htab == NULL)
6890     return FALSE;
6891
6892   /* Find the corresponding function descriptor symbol.  */
6893   fdh = lookup_fdh (fh, htab);
6894
6895   /* Resolve undefined references to dot-symbols as the value
6896      in the function descriptor, if we have one in a regular object.
6897      This is to satisfy cases like ".quad .foo".  Calls to functions
6898      in dynamic objects are handled elsewhere.  */
6899   if ((fh->elf.root.type == bfd_link_hash_undefined
6900        || fh->elf.root.type == bfd_link_hash_undefweak)
6901       && (fdh->elf.root.type == bfd_link_hash_defined
6902           || fdh->elf.root.type == bfd_link_hash_defweak)
6903       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6904       && opd_entry_value (fdh->elf.root.u.def.section,
6905                           fdh->elf.root.u.def.value,
6906                           &fh->elf.root.u.def.section,
6907                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6908     {
6909       fh->elf.root.type = fdh->elf.root.type;
6910       fh->elf.forced_local = 1;
6911       fh->elf.def_regular = fdh->elf.def_regular;
6912       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6913     }
6914
6915   if (!fh->elf.dynamic)
6916     {
6917       struct plt_entry *ent;
6918
6919       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6920         if (ent->plt.refcount > 0)
6921           break;
6922       if (ent == NULL)
6923         return TRUE;
6924     }
6925
6926   /* Create a descriptor as undefined if necessary.  */
6927   if (fdh == NULL
6928       && !bfd_link_executable (info)
6929       && (fh->elf.root.type == bfd_link_hash_undefined
6930           || fh->elf.root.type == bfd_link_hash_undefweak))
6931     {
6932       fdh = make_fdh (info, fh);
6933       if (fdh == NULL)
6934         return FALSE;
6935     }
6936
6937   /* We can't support overriding of symbols on a fake descriptor.  */
6938   if (fdh != NULL
6939       && fdh->fake
6940       && (fh->elf.root.type == bfd_link_hash_defined
6941           || fh->elf.root.type == bfd_link_hash_defweak))
6942     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6943
6944   /* Transfer dynamic linking information to the function descriptor.  */
6945   if (fdh != NULL)
6946     {
6947       fdh->elf.ref_regular |= fh->elf.ref_regular;
6948       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6949       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6950       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6951       fdh->elf.dynamic |= fh->elf.dynamic;
6952       fdh->elf.needs_plt |= (fh->elf.needs_plt
6953                              || fh->elf.type == STT_FUNC
6954                              || fh->elf.type == STT_GNU_IFUNC);
6955       move_plt_plist (fh, fdh);
6956
6957       if (!fdh->elf.forced_local
6958           && fh->elf.dynindx != -1)
6959         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6960           return FALSE;
6961     }
6962
6963   /* Now that the info is on the function descriptor, clear the
6964      function code sym info.  Any function code syms for which we
6965      don't have a definition in a regular file, we force local.
6966      This prevents a shared library from exporting syms that have
6967      been imported from another library.  Function code syms that
6968      are really in the library we must leave global to prevent the
6969      linker dragging in a definition from a static library.  */
6970   force_local = (!fh->elf.def_regular
6971                  || fdh == NULL
6972                  || !fdh->elf.def_regular
6973                  || fdh->elf.forced_local);
6974   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6975
6976   return TRUE;
6977 }
6978
6979 static const struct sfpr_def_parms save_res_funcs[] =
6980   {
6981     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6982     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6983     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6984     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6985     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6986     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6987     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6988     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6989     { "._savef", 14, 31, savefpr, savefpr1_tail },
6990     { "._restf", 14, 31, restfpr, restfpr1_tail },
6991     { "_savevr_", 20, 31, savevr, savevr_tail },
6992     { "_restvr_", 20, 31, restvr, restvr_tail }
6993   };
6994
6995 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6996    this hook to a) provide some gcc support functions, and b) transfer
6997    dynamic linking information gathered so far on function code symbol
6998    entries, to their corresponding function descriptor symbol entries.  */
6999
7000 static bfd_boolean
7001 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7002                             struct bfd_link_info *info)
7003 {
7004   struct ppc_link_hash_table *htab;
7005
7006   htab = ppc_hash_table (info);
7007   if (htab == NULL)
7008     return FALSE;
7009
7010   /* Provide any missing _save* and _rest* functions.  */
7011   if (htab->sfpr != NULL)
7012     {
7013       unsigned int i;
7014
7015       htab->sfpr->size = 0;
7016       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7017         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7018           return FALSE;
7019       if (htab->sfpr->size == 0)
7020         htab->sfpr->flags |= SEC_EXCLUDE;
7021     }
7022
7023   if (bfd_link_relocatable (info))
7024     return TRUE;
7025
7026   if (htab->elf.hgot != NULL)
7027     {
7028       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7029       /* Make .TOC. defined so as to prevent it being made dynamic.
7030          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7031       if (!htab->elf.hgot->def_regular
7032           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7033         {
7034           htab->elf.hgot->root.type = bfd_link_hash_defined;
7035           htab->elf.hgot->root.u.def.value = 0;
7036           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7037           htab->elf.hgot->def_regular = 1;
7038           htab->elf.hgot->root.linker_def = 1;
7039         }
7040       htab->elf.hgot->type = STT_OBJECT;
7041       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7042                                | STV_HIDDEN);
7043     }
7044
7045   if (htab->need_func_desc_adj)
7046     {
7047       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7048       htab->need_func_desc_adj = 0;
7049     }
7050
7051   return TRUE;
7052 }
7053
7054 /* Find dynamic relocs for H that apply to read-only sections.  */
7055
7056 static asection *
7057 readonly_dynrelocs (struct elf_link_hash_entry *h)
7058 {
7059   struct ppc_link_hash_entry *eh;
7060   struct elf_dyn_relocs *p;
7061
7062   eh = (struct ppc_link_hash_entry *) h;
7063   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7064     {
7065       asection *s = p->sec->output_section;
7066
7067       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7068         return p->sec;
7069     }
7070   return NULL;
7071 }
7072
7073 /* Return true if we have dynamic relocs against H or any of its weak
7074    aliases, that apply to read-only sections.  Cannot be used after
7075    size_dynamic_sections.  */
7076
7077 static bfd_boolean
7078 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7079 {
7080   struct ppc_link_hash_entry *eh;
7081
7082   eh = (struct ppc_link_hash_entry *) h;
7083   do
7084     {
7085       if (readonly_dynrelocs (&eh->elf))
7086         return TRUE;
7087       eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7088     } while (eh != NULL && &eh->elf != h);
7089
7090   return FALSE;
7091 }
7092
7093 /* Return whether EH has pc-relative dynamic relocs.  */
7094
7095 static bfd_boolean
7096 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7097 {
7098   struct elf_dyn_relocs *p;
7099
7100   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7101     if (p->pc_count != 0)
7102       return TRUE;
7103   return FALSE;
7104 }
7105
7106 /* Return true if a global entry stub will be created for H.  Valid
7107    for ELFv2 before plt entries have been allocated.  */
7108
7109 static bfd_boolean
7110 global_entry_stub (struct elf_link_hash_entry *h)
7111 {
7112   struct plt_entry *pent;
7113
7114   if (!h->pointer_equality_needed
7115       || h->def_regular)
7116     return FALSE;
7117
7118   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7119     if (pent->plt.refcount > 0
7120         && pent->addend == 0)
7121       return TRUE;
7122
7123   return FALSE;
7124 }
7125
7126 /* Adjust a symbol defined by a dynamic object and referenced by a
7127    regular object.  The current definition is in some section of the
7128    dynamic object, but we're not including those sections.  We have to
7129    change the definition to something the rest of the link can
7130    understand.  */
7131
7132 static bfd_boolean
7133 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7134                                  struct elf_link_hash_entry *h)
7135 {
7136   struct ppc_link_hash_table *htab;
7137   asection *s, *srel;
7138
7139   htab = ppc_hash_table (info);
7140   if (htab == NULL)
7141     return FALSE;
7142
7143   /* Deal with function syms.  */
7144   if (h->type == STT_FUNC
7145       || h->type == STT_GNU_IFUNC
7146       || h->needs_plt)
7147     {
7148       bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7149                            || SYMBOL_CALLS_LOCAL (info, h)
7150                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7151       /* Discard dyn_relocs when non-pic if we've decided that a
7152          function symbol is local and not an ifunc.  We keep dynamic
7153          relocs for ifuncs when local rather than always emitting a
7154          plt call stub for them and defining the symbol on the call
7155          stub.  We can't do that for ELFv1 anyway (a function symbol
7156          is defined on a descriptor, not code) and it can be faster at
7157          run-time due to not needing to bounce through a stub.  The
7158          dyn_relocs for ifuncs will be applied even in a static
7159          executable.  */
7160       if (!bfd_link_pic (info)
7161           && h->type != STT_GNU_IFUNC
7162           && local)
7163         ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7164
7165       /* Clear procedure linkage table information for any symbol that
7166          won't need a .plt entry.  */
7167       struct plt_entry *ent;
7168       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7169         if (ent->plt.refcount > 0)
7170           break;
7171       if (ent == NULL
7172           || (h->type != STT_GNU_IFUNC && local))
7173         {
7174           h->plt.plist = NULL;
7175           h->needs_plt = 0;
7176           h->pointer_equality_needed = 0;
7177         }
7178       else if (abiversion (info->output_bfd) >= 2)
7179         {
7180           /* Taking a function's address in a read/write section
7181              doesn't require us to define the function symbol in the
7182              executable on a global entry stub.  A dynamic reloc can
7183              be used instead.  The reason we prefer a few more dynamic
7184              relocs is that calling via a global entry stub costs a
7185              few more instructions, and pointer_equality_needed causes
7186              extra work in ld.so when resolving these symbols.  */
7187           if (global_entry_stub (h))
7188             {
7189               if (!readonly_dynrelocs (h))
7190                 {
7191                   h->pointer_equality_needed = 0;
7192                   /* If we haven't seen a branch reloc then we don't need
7193                      a plt entry.  */
7194                   if (!h->needs_plt)
7195                     h->plt.plist = NULL;
7196                 }
7197               else if (!bfd_link_pic (info))
7198                 /* We are going to be defining the function symbol on the
7199                    plt stub, so no dyn_relocs needed when non-pic.  */
7200                 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7201             }
7202
7203           /* ELFv2 function symbols can't have copy relocs.  */
7204           return TRUE;
7205         }
7206       else if (!h->needs_plt
7207                && !readonly_dynrelocs (h))
7208         {
7209           /* If we haven't seen a branch reloc then we don't need a
7210              plt entry.  */
7211           h->plt.plist = NULL;
7212           h->pointer_equality_needed = 0;
7213           return TRUE;
7214         }
7215     }
7216   else
7217     h->plt.plist = NULL;
7218
7219   /* If this is a weak symbol, and there is a real definition, the
7220      processor independent code will have arranged for us to see the
7221      real definition first, and we can just use the same value.  */
7222   if (h->is_weakalias)
7223     {
7224       struct elf_link_hash_entry *def = weakdef (h);
7225       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7226       h->root.u.def.section = def->root.u.def.section;
7227       h->root.u.def.value = def->root.u.def.value;
7228       if (ELIMINATE_COPY_RELOCS)
7229         h->non_got_ref = def->non_got_ref;
7230       return TRUE;
7231     }
7232
7233   /* If we are creating a shared library, we must presume that the
7234      only references to the symbol are via the global offset table.
7235      For such cases we need not do anything here; the relocations will
7236      be handled correctly by relocate_section.  */
7237   if (bfd_link_pic (info))
7238     return TRUE;
7239
7240   /* If there are no references to this symbol that do not use the
7241      GOT, we don't need to generate a copy reloc.  */
7242   if (!h->non_got_ref)
7243     return TRUE;
7244
7245   /* Don't generate a copy reloc for symbols defined in the executable.  */
7246   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7247
7248       /* If -z nocopyreloc was given, don't generate them either.  */
7249       || info->nocopyreloc
7250
7251       /* If we didn't find any dynamic relocs in read-only sections, then
7252          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7253       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7254
7255       /* Protected variables do not work with .dynbss.  The copy in
7256          .dynbss won't be used by the shared library with the protected
7257          definition for the variable.  Text relocations are preferable
7258          to an incorrect program.  */
7259       || h->protected_def)
7260     return TRUE;
7261
7262   if (h->plt.plist != NULL)
7263     {
7264       /* We should never get here, but unfortunately there are versions
7265          of gcc out there that improperly (for this ABI) put initialized
7266          function pointers, vtable refs and suchlike in read-only
7267          sections.  Allow them to proceed, but warn that this might
7268          break at runtime.  */
7269       info->callbacks->einfo
7270         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7271            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7272          h->root.root.string);
7273     }
7274
7275   /* This is a reference to a symbol defined by a dynamic object which
7276      is not a function.  */
7277
7278   /* We must allocate the symbol in our .dynbss section, which will
7279      become part of the .bss section of the executable.  There will be
7280      an entry for this symbol in the .dynsym section.  The dynamic
7281      object will contain position independent code, so all references
7282      from the dynamic object to this symbol will go through the global
7283      offset table.  The dynamic linker will use the .dynsym entry to
7284      determine the address it must put in the global offset table, so
7285      both the dynamic object and the regular object will refer to the
7286      same memory location for the variable.  */
7287
7288   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7289      to copy the initial value out of the dynamic object and into the
7290      runtime process image.  We need to remember the offset into the
7291      .rela.bss section we are going to use.  */
7292   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7293     {
7294       s = htab->elf.sdynrelro;
7295       srel = htab->elf.sreldynrelro;
7296     }
7297   else
7298     {
7299       s = htab->elf.sdynbss;
7300       srel = htab->elf.srelbss;
7301     }
7302   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7303     {
7304       srel->size += sizeof (Elf64_External_Rela);
7305       h->needs_copy = 1;
7306     }
7307
7308   /* We no longer want dyn_relocs.  */
7309   ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7310   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7311 }
7312
7313 /* If given a function descriptor symbol, hide both the function code
7314    sym and the descriptor.  */
7315 static void
7316 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7317                        struct elf_link_hash_entry *h,
7318                        bfd_boolean force_local)
7319 {
7320   struct ppc_link_hash_entry *eh;
7321   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7322
7323   eh = (struct ppc_link_hash_entry *) h;
7324   if (eh->is_func_descriptor)
7325     {
7326       struct ppc_link_hash_entry *fh = eh->oh;
7327
7328       if (fh == NULL)
7329         {
7330           const char *p, *q;
7331           struct elf_link_hash_table *htab = elf_hash_table (info);
7332           char save;
7333
7334           /* We aren't supposed to use alloca in BFD because on
7335              systems which do not have alloca the version in libiberty
7336              calls xmalloc, which might cause the program to crash
7337              when it runs out of memory.  This function doesn't have a
7338              return status, so there's no way to gracefully return an
7339              error.  So cheat.  We know that string[-1] can be safely
7340              accessed;  It's either a string in an ELF string table,
7341              or allocated in an objalloc structure.  */
7342
7343           p = eh->elf.root.root.string - 1;
7344           save = *p;
7345           *(char *) p = '.';
7346           fh = (struct ppc_link_hash_entry *)
7347             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7348           *(char *) p = save;
7349
7350           /* Unfortunately, if it so happens that the string we were
7351              looking for was allocated immediately before this string,
7352              then we overwrote the string terminator.  That's the only
7353              reason the lookup should fail.  */
7354           if (fh == NULL)
7355             {
7356               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7357               while (q >= eh->elf.root.root.string && *q == *p)
7358                 --q, --p;
7359               if (q < eh->elf.root.root.string && *p == '.')
7360                 fh = (struct ppc_link_hash_entry *)
7361                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7362             }
7363           if (fh != NULL)
7364             {
7365               eh->oh = fh;
7366               fh->oh = eh;
7367             }
7368         }
7369       if (fh != NULL)
7370         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7371     }
7372 }
7373
7374 static bfd_boolean
7375 get_sym_h (struct elf_link_hash_entry **hp,
7376            Elf_Internal_Sym **symp,
7377            asection **symsecp,
7378            unsigned char **tls_maskp,
7379            Elf_Internal_Sym **locsymsp,
7380            unsigned long r_symndx,
7381            bfd *ibfd)
7382 {
7383   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7384
7385   if (r_symndx >= symtab_hdr->sh_info)
7386     {
7387       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7388       struct elf_link_hash_entry *h;
7389
7390       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7391       h = elf_follow_link (h);
7392
7393       if (hp != NULL)
7394         *hp = h;
7395
7396       if (symp != NULL)
7397         *symp = NULL;
7398
7399       if (symsecp != NULL)
7400         {
7401           asection *symsec = NULL;
7402           if (h->root.type == bfd_link_hash_defined
7403               || h->root.type == bfd_link_hash_defweak)
7404             symsec = h->root.u.def.section;
7405           *symsecp = symsec;
7406         }
7407
7408       if (tls_maskp != NULL)
7409         {
7410           struct ppc_link_hash_entry *eh;
7411
7412           eh = (struct ppc_link_hash_entry *) h;
7413           *tls_maskp = &eh->tls_mask;
7414         }
7415     }
7416   else
7417     {
7418       Elf_Internal_Sym *sym;
7419       Elf_Internal_Sym *locsyms = *locsymsp;
7420
7421       if (locsyms == NULL)
7422         {
7423           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7424           if (locsyms == NULL)
7425             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7426                                             symtab_hdr->sh_info,
7427                                             0, NULL, NULL, NULL);
7428           if (locsyms == NULL)
7429             return FALSE;
7430           *locsymsp = locsyms;
7431         }
7432       sym = locsyms + r_symndx;
7433
7434       if (hp != NULL)
7435         *hp = NULL;
7436
7437       if (symp != NULL)
7438         *symp = sym;
7439
7440       if (symsecp != NULL)
7441         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7442
7443       if (tls_maskp != NULL)
7444         {
7445           struct got_entry **lgot_ents;
7446           unsigned char *tls_mask;
7447
7448           tls_mask = NULL;
7449           lgot_ents = elf_local_got_ents (ibfd);
7450           if (lgot_ents != NULL)
7451             {
7452               struct plt_entry **local_plt = (struct plt_entry **)
7453                 (lgot_ents + symtab_hdr->sh_info);
7454               unsigned char *lgot_masks = (unsigned char *)
7455                 (local_plt + symtab_hdr->sh_info);
7456               tls_mask = &lgot_masks[r_symndx];
7457             }
7458           *tls_maskp = tls_mask;
7459         }
7460     }
7461   return TRUE;
7462 }
7463
7464 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7465    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7466    type suitable for optimization, and 1 otherwise.  */
7467
7468 static int
7469 get_tls_mask (unsigned char **tls_maskp,
7470               unsigned long *toc_symndx,
7471               bfd_vma *toc_addend,
7472               Elf_Internal_Sym **locsymsp,
7473               const Elf_Internal_Rela *rel,
7474               bfd *ibfd)
7475 {
7476   unsigned long r_symndx;
7477   int next_r;
7478   struct elf_link_hash_entry *h;
7479   Elf_Internal_Sym *sym;
7480   asection *sec;
7481   bfd_vma off;
7482
7483   r_symndx = ELF64_R_SYM (rel->r_info);
7484   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7485     return 0;
7486
7487   if ((*tls_maskp != NULL && **tls_maskp != 0)
7488       || sec == NULL
7489       || ppc64_elf_section_data (sec) == NULL
7490       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7491     return 1;
7492
7493   /* Look inside a TOC section too.  */
7494   if (h != NULL)
7495     {
7496       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7497       off = h->root.u.def.value;
7498     }
7499   else
7500     off = sym->st_value;
7501   off += rel->r_addend;
7502   BFD_ASSERT (off % 8 == 0);
7503   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7504   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7505   if (toc_symndx != NULL)
7506     *toc_symndx = r_symndx;
7507   if (toc_addend != NULL)
7508     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7509   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7510     return 0;
7511   if ((h == NULL || is_static_defined (h))
7512       && (next_r == -1 || next_r == -2))
7513     return 1 - next_r;
7514   return 1;
7515 }
7516
7517 /* Find (or create) an entry in the tocsave hash table.  */
7518
7519 static struct tocsave_entry *
7520 tocsave_find (struct ppc_link_hash_table *htab,
7521               enum insert_option insert,
7522               Elf_Internal_Sym **local_syms,
7523               const Elf_Internal_Rela *irela,
7524               bfd *ibfd)
7525 {
7526   unsigned long r_indx;
7527   struct elf_link_hash_entry *h;
7528   Elf_Internal_Sym *sym;
7529   struct tocsave_entry ent, *p;
7530   hashval_t hash;
7531   struct tocsave_entry **slot;
7532
7533   r_indx = ELF64_R_SYM (irela->r_info);
7534   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7535     return NULL;
7536   if (ent.sec == NULL || ent.sec->output_section == NULL)
7537     {
7538       _bfd_error_handler
7539         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7540       return NULL;
7541     }
7542
7543   if (h != NULL)
7544     ent.offset = h->root.u.def.value;
7545   else
7546     ent.offset = sym->st_value;
7547   ent.offset += irela->r_addend;
7548
7549   hash = tocsave_htab_hash (&ent);
7550   slot = ((struct tocsave_entry **)
7551           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7552   if (slot == NULL)
7553     return NULL;
7554
7555   if (*slot == NULL)
7556     {
7557       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7558       if (p == NULL)
7559         return NULL;
7560       *p = ent;
7561       *slot = p;
7562     }
7563   return *slot;
7564 }
7565
7566 /* Adjust all global syms defined in opd sections.  In gcc generated
7567    code for the old ABI, these will already have been done.  */
7568
7569 static bfd_boolean
7570 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7571 {
7572   struct ppc_link_hash_entry *eh;
7573   asection *sym_sec;
7574   struct _opd_sec_data *opd;
7575
7576   if (h->root.type == bfd_link_hash_indirect)
7577     return TRUE;
7578
7579   if (h->root.type != bfd_link_hash_defined
7580       && h->root.type != bfd_link_hash_defweak)
7581     return TRUE;
7582
7583   eh = (struct ppc_link_hash_entry *) h;
7584   if (eh->adjust_done)
7585     return TRUE;
7586
7587   sym_sec = eh->elf.root.u.def.section;
7588   opd = get_opd_info (sym_sec);
7589   if (opd != NULL && opd->adjust != NULL)
7590     {
7591       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7592       if (adjust == -1)
7593         {
7594           /* This entry has been deleted.  */
7595           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7596           if (dsec == NULL)
7597             {
7598               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7599                 if (discarded_section (dsec))
7600                   {
7601                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7602                     break;
7603                   }
7604             }
7605           eh->elf.root.u.def.value = 0;
7606           eh->elf.root.u.def.section = dsec;
7607         }
7608       else
7609         eh->elf.root.u.def.value += adjust;
7610       eh->adjust_done = 1;
7611     }
7612   return TRUE;
7613 }
7614
7615 /* Handles decrementing dynamic reloc counts for the reloc specified by
7616    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7617    have already been determined.  */
7618
7619 static bfd_boolean
7620 dec_dynrel_count (bfd_vma r_info,
7621                   asection *sec,
7622                   struct bfd_link_info *info,
7623                   Elf_Internal_Sym **local_syms,
7624                   struct elf_link_hash_entry *h,
7625                   Elf_Internal_Sym *sym)
7626 {
7627   enum elf_ppc64_reloc_type r_type;
7628   asection *sym_sec = NULL;
7629
7630   /* Can this reloc be dynamic?  This switch, and later tests here
7631      should be kept in sync with the code in check_relocs.  */
7632   r_type = ELF64_R_TYPE (r_info);
7633   switch (r_type)
7634     {
7635     default:
7636       return TRUE;
7637
7638     case R_PPC64_TPREL16:
7639     case R_PPC64_TPREL16_LO:
7640     case R_PPC64_TPREL16_HI:
7641     case R_PPC64_TPREL16_HA:
7642     case R_PPC64_TPREL16_DS:
7643     case R_PPC64_TPREL16_LO_DS:
7644     case R_PPC64_TPREL16_HIGH:
7645     case R_PPC64_TPREL16_HIGHA:
7646     case R_PPC64_TPREL16_HIGHER:
7647     case R_PPC64_TPREL16_HIGHERA:
7648     case R_PPC64_TPREL16_HIGHEST:
7649     case R_PPC64_TPREL16_HIGHESTA:
7650     case R_PPC64_TPREL64:
7651     case R_PPC64_DTPMOD64:
7652     case R_PPC64_DTPREL64:
7653     case R_PPC64_ADDR64:
7654     case R_PPC64_REL30:
7655     case R_PPC64_REL32:
7656     case R_PPC64_REL64:
7657     case R_PPC64_ADDR14:
7658     case R_PPC64_ADDR14_BRNTAKEN:
7659     case R_PPC64_ADDR14_BRTAKEN:
7660     case R_PPC64_ADDR16:
7661     case R_PPC64_ADDR16_DS:
7662     case R_PPC64_ADDR16_HA:
7663     case R_PPC64_ADDR16_HI:
7664     case R_PPC64_ADDR16_HIGH:
7665     case R_PPC64_ADDR16_HIGHA:
7666     case R_PPC64_ADDR16_HIGHER:
7667     case R_PPC64_ADDR16_HIGHERA:
7668     case R_PPC64_ADDR16_HIGHEST:
7669     case R_PPC64_ADDR16_HIGHESTA:
7670     case R_PPC64_ADDR16_LO:
7671     case R_PPC64_ADDR16_LO_DS:
7672     case R_PPC64_ADDR24:
7673     case R_PPC64_ADDR32:
7674     case R_PPC64_UADDR16:
7675     case R_PPC64_UADDR32:
7676     case R_PPC64_UADDR64:
7677     case R_PPC64_TOC:
7678       break;
7679     }
7680
7681   if (local_syms != NULL)
7682     {
7683       unsigned long r_symndx;
7684       bfd *ibfd = sec->owner;
7685
7686       r_symndx = ELF64_R_SYM (r_info);
7687       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7688         return FALSE;
7689     }
7690
7691   if ((bfd_link_pic (info)
7692        && (must_be_dyn_reloc (info, r_type)
7693            || (h != NULL
7694                && (!SYMBOLIC_BIND (info, h)
7695                    || h->root.type == bfd_link_hash_defweak
7696                    || !h->def_regular))))
7697       || (ELIMINATE_COPY_RELOCS
7698           && !bfd_link_pic (info)
7699           && h != NULL
7700           && (h->root.type == bfd_link_hash_defweak
7701               || !h->def_regular)))
7702     ;
7703   else
7704     return TRUE;
7705
7706   if (h != NULL)
7707     {
7708       struct elf_dyn_relocs *p;
7709       struct elf_dyn_relocs **pp;
7710       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7711
7712       /* elf_gc_sweep may have already removed all dyn relocs associated
7713          with local syms for a given section.  Also, symbol flags are
7714          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7715          report a dynreloc miscount.  */
7716       if (*pp == NULL && info->gc_sections)
7717         return TRUE;
7718
7719       while ((p = *pp) != NULL)
7720         {
7721           if (p->sec == sec)
7722             {
7723               if (!must_be_dyn_reloc (info, r_type))
7724                 p->pc_count -= 1;
7725               p->count -= 1;
7726               if (p->count == 0)
7727                 *pp = p->next;
7728               return TRUE;
7729             }
7730           pp = &p->next;
7731         }
7732     }
7733   else
7734     {
7735       struct ppc_dyn_relocs *p;
7736       struct ppc_dyn_relocs **pp;
7737       void *vpp;
7738       bfd_boolean is_ifunc;
7739
7740       if (local_syms == NULL)
7741         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7742       if (sym_sec == NULL)
7743         sym_sec = sec;
7744
7745       vpp = &elf_section_data (sym_sec)->local_dynrel;
7746       pp = (struct ppc_dyn_relocs **) vpp;
7747
7748       if (*pp == NULL && info->gc_sections)
7749         return TRUE;
7750
7751       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7752       while ((p = *pp) != NULL)
7753         {
7754           if (p->sec == sec && p->ifunc == is_ifunc)
7755             {
7756               p->count -= 1;
7757               if (p->count == 0)
7758                 *pp = p->next;
7759               return TRUE;
7760             }
7761           pp = &p->next;
7762         }
7763     }
7764
7765   /* xgettext:c-format */
7766   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7767                           sec->owner, sec);
7768   bfd_set_error (bfd_error_bad_value);
7769   return FALSE;
7770 }
7771
7772 /* Remove unused Official Procedure Descriptor entries.  Currently we
7773    only remove those associated with functions in discarded link-once
7774    sections, or weakly defined functions that have been overridden.  It
7775    would be possible to remove many more entries for statically linked
7776    applications.  */
7777
7778 bfd_boolean
7779 ppc64_elf_edit_opd (struct bfd_link_info *info)
7780 {
7781   bfd *ibfd;
7782   bfd_boolean some_edited = FALSE;
7783   asection *need_pad = NULL;
7784   struct ppc_link_hash_table *htab;
7785
7786   htab = ppc_hash_table (info);
7787   if (htab == NULL)
7788     return FALSE;
7789
7790   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7791     {
7792       asection *sec;
7793       Elf_Internal_Rela *relstart, *rel, *relend;
7794       Elf_Internal_Shdr *symtab_hdr;
7795       Elf_Internal_Sym *local_syms;
7796       struct _opd_sec_data *opd;
7797       bfd_boolean need_edit, add_aux_fields, broken;
7798       bfd_size_type cnt_16b = 0;
7799
7800       if (!is_ppc64_elf (ibfd))
7801         continue;
7802
7803       sec = bfd_get_section_by_name (ibfd, ".opd");
7804       if (sec == NULL || sec->size == 0)
7805         continue;
7806
7807       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7808         continue;
7809
7810       if (sec->output_section == bfd_abs_section_ptr)
7811         continue;
7812
7813       /* Look through the section relocs.  */
7814       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7815         continue;
7816
7817       local_syms = NULL;
7818       symtab_hdr = &elf_symtab_hdr (ibfd);
7819
7820       /* Read the relocations.  */
7821       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7822                                             info->keep_memory);
7823       if (relstart == NULL)
7824         return FALSE;
7825
7826       /* First run through the relocs to check they are sane, and to
7827          determine whether we need to edit this opd section.  */
7828       need_edit = FALSE;
7829       broken = FALSE;
7830       need_pad = sec;
7831       relend = relstart + sec->reloc_count;
7832       for (rel = relstart; rel < relend; )
7833         {
7834           enum elf_ppc64_reloc_type r_type;
7835           unsigned long r_symndx;
7836           asection *sym_sec;
7837           struct elf_link_hash_entry *h;
7838           Elf_Internal_Sym *sym;
7839           bfd_vma offset;
7840
7841           /* .opd contains an array of 16 or 24 byte entries.  We're
7842              only interested in the reloc pointing to a function entry
7843              point.  */
7844           offset = rel->r_offset;
7845           if (rel + 1 == relend
7846               || rel[1].r_offset != offset + 8)
7847             {
7848               /* If someone messes with .opd alignment then after a
7849                  "ld -r" we might have padding in the middle of .opd.
7850                  Also, there's nothing to prevent someone putting
7851                  something silly in .opd with the assembler.  No .opd
7852                  optimization for them!  */
7853             broken_opd:
7854               _bfd_error_handler
7855                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7856               broken = TRUE;
7857               break;
7858             }
7859
7860           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7861               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7862             {
7863               _bfd_error_handler
7864                 /* xgettext:c-format */
7865                 (_("%B: unexpected reloc type %u in .opd section"),
7866                  ibfd, r_type);
7867               broken = TRUE;
7868               break;
7869             }
7870
7871           r_symndx = ELF64_R_SYM (rel->r_info);
7872           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7873                           r_symndx, ibfd))
7874             goto error_ret;
7875
7876           if (sym_sec == NULL || sym_sec->owner == NULL)
7877             {
7878               const char *sym_name;
7879               if (h != NULL)
7880                 sym_name = h->root.root.string;
7881               else
7882                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7883                                              sym_sec);
7884
7885               _bfd_error_handler
7886                 /* xgettext:c-format */
7887                 (_("%B: undefined sym `%s' in .opd section"),
7888                  ibfd, sym_name);
7889               broken = TRUE;
7890               break;
7891             }
7892
7893           /* opd entries are always for functions defined in the
7894              current input bfd.  If the symbol isn't defined in the
7895              input bfd, then we won't be using the function in this
7896              bfd;  It must be defined in a linkonce section in another
7897              bfd, or is weak.  It's also possible that we are
7898              discarding the function due to a linker script /DISCARD/,
7899              which we test for via the output_section.  */
7900           if (sym_sec->owner != ibfd
7901               || sym_sec->output_section == bfd_abs_section_ptr)
7902             need_edit = TRUE;
7903
7904           rel += 2;
7905           if (rel + 1 == relend
7906               || (rel + 2 < relend
7907                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7908             ++rel;
7909
7910           if (rel == relend)
7911             {
7912               if (sec->size == offset + 24)
7913                 {
7914                   need_pad = NULL;
7915                   break;
7916                 }
7917               if (sec->size == offset + 16)
7918                 {
7919                   cnt_16b++;
7920                   break;
7921                 }
7922               goto broken_opd;
7923             }
7924           else if (rel + 1 < relend
7925                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7926                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7927             {
7928               if (rel[0].r_offset == offset + 16)
7929                 cnt_16b++;
7930               else if (rel[0].r_offset != offset + 24)
7931                 goto broken_opd;
7932             }
7933           else
7934             goto broken_opd;
7935         }
7936
7937       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7938
7939       if (!broken && (need_edit || add_aux_fields))
7940         {
7941           Elf_Internal_Rela *write_rel;
7942           Elf_Internal_Shdr *rel_hdr;
7943           bfd_byte *rptr, *wptr;
7944           bfd_byte *new_contents;
7945           bfd_size_type amt;
7946
7947           new_contents = NULL;
7948           amt = OPD_NDX (sec->size) * sizeof (long);
7949           opd = &ppc64_elf_section_data (sec)->u.opd;
7950           opd->adjust = bfd_zalloc (sec->owner, amt);
7951           if (opd->adjust == NULL)
7952             return FALSE;
7953
7954           /* This seems a waste of time as input .opd sections are all
7955              zeros as generated by gcc, but I suppose there's no reason
7956              this will always be so.  We might start putting something in
7957              the third word of .opd entries.  */
7958           if ((sec->flags & SEC_IN_MEMORY) == 0)
7959             {
7960               bfd_byte *loc;
7961               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7962                 {
7963                   if (loc != NULL)
7964                     free (loc);
7965                 error_ret:
7966                   if (local_syms != NULL
7967                       && symtab_hdr->contents != (unsigned char *) local_syms)
7968                     free (local_syms);
7969                   if (elf_section_data (sec)->relocs != relstart)
7970                     free (relstart);
7971                   return FALSE;
7972                 }
7973               sec->contents = loc;
7974               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7975             }
7976
7977           elf_section_data (sec)->relocs = relstart;
7978
7979           new_contents = sec->contents;
7980           if (add_aux_fields)
7981             {
7982               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7983               if (new_contents == NULL)
7984                 return FALSE;
7985               need_pad = NULL;
7986             }
7987           wptr = new_contents;
7988           rptr = sec->contents;
7989           write_rel = relstart;
7990           for (rel = relstart; rel < relend; )
7991             {
7992               unsigned long r_symndx;
7993               asection *sym_sec;
7994               struct elf_link_hash_entry *h;
7995               struct ppc_link_hash_entry *fdh = NULL;
7996               Elf_Internal_Sym *sym;
7997               long opd_ent_size;
7998               Elf_Internal_Rela *next_rel;
7999               bfd_boolean skip;
8000
8001               r_symndx = ELF64_R_SYM (rel->r_info);
8002               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8003                               r_symndx, ibfd))
8004                 goto error_ret;
8005
8006               next_rel = rel + 2;
8007               if (next_rel + 1 == relend
8008                   || (next_rel + 2 < relend
8009                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8010                 ++next_rel;
8011
8012               /* See if the .opd entry is full 24 byte or
8013                  16 byte (with fd_aux entry overlapped with next
8014                  fd_func).  */
8015               opd_ent_size = 24;
8016               if (next_rel == relend)
8017                 {
8018                   if (sec->size == rel->r_offset + 16)
8019                     opd_ent_size = 16;
8020                 }
8021               else if (next_rel->r_offset == rel->r_offset + 16)
8022                 opd_ent_size = 16;
8023
8024               if (h != NULL
8025                   && h->root.root.string[0] == '.')
8026                 {
8027                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8028                   if (fdh != NULL)
8029                     {
8030                       fdh = ppc_follow_link (fdh);
8031                       if (fdh->elf.root.type != bfd_link_hash_defined
8032                           && fdh->elf.root.type != bfd_link_hash_defweak)
8033                         fdh = NULL;
8034                     }
8035                 }
8036
8037               skip = (sym_sec->owner != ibfd
8038                       || sym_sec->output_section == bfd_abs_section_ptr);
8039               if (skip)
8040                 {
8041                   if (fdh != NULL && sym_sec->owner == ibfd)
8042                     {
8043                       /* Arrange for the function descriptor sym
8044                          to be dropped.  */
8045                       fdh->elf.root.u.def.value = 0;
8046                       fdh->elf.root.u.def.section = sym_sec;
8047                     }
8048                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8049
8050                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8051                     rel = next_rel;
8052                   else
8053                     while (1)
8054                       {
8055                         if (!dec_dynrel_count (rel->r_info, sec, info,
8056                                                NULL, h, sym))
8057                           goto error_ret;
8058
8059                         if (++rel == next_rel)
8060                           break;
8061
8062                         r_symndx = ELF64_R_SYM (rel->r_info);
8063                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8064                                         r_symndx, ibfd))
8065                           goto error_ret;
8066                       }
8067                 }
8068               else
8069                 {
8070                   /* We'll be keeping this opd entry.  */
8071                   long adjust;
8072
8073                   if (fdh != NULL)
8074                     {
8075                       /* Redefine the function descriptor symbol to
8076                          this location in the opd section.  It is
8077                          necessary to update the value here rather
8078                          than using an array of adjustments as we do
8079                          for local symbols, because various places
8080                          in the generic ELF code use the value
8081                          stored in u.def.value.  */
8082                       fdh->elf.root.u.def.value = wptr - new_contents;
8083                       fdh->adjust_done = 1;
8084                     }
8085
8086                   /* Local syms are a bit tricky.  We could
8087                      tweak them as they can be cached, but
8088                      we'd need to look through the local syms
8089                      for the function descriptor sym which we
8090                      don't have at the moment.  So keep an
8091                      array of adjustments.  */
8092                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8093                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8094
8095                   if (wptr != rptr)
8096                     memcpy (wptr, rptr, opd_ent_size);
8097                   wptr += opd_ent_size;
8098                   if (add_aux_fields && opd_ent_size == 16)
8099                     {
8100                       memset (wptr, '\0', 8);
8101                       wptr += 8;
8102                     }
8103
8104                   /* We need to adjust any reloc offsets to point to the
8105                      new opd entries.  */
8106                   for ( ; rel != next_rel; ++rel)
8107                     {
8108                       rel->r_offset += adjust;
8109                       if (write_rel != rel)
8110                         memcpy (write_rel, rel, sizeof (*rel));
8111                       ++write_rel;
8112                     }
8113                 }
8114
8115               rptr += opd_ent_size;
8116             }
8117
8118           sec->size = wptr - new_contents;
8119           sec->reloc_count = write_rel - relstart;
8120           if (add_aux_fields)
8121             {
8122               free (sec->contents);
8123               sec->contents = new_contents;
8124             }
8125
8126           /* Fudge the header size too, as this is used later in
8127              elf_bfd_final_link if we are emitting relocs.  */
8128           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8129           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8130           some_edited = TRUE;
8131         }
8132       else if (elf_section_data (sec)->relocs != relstart)
8133         free (relstart);
8134
8135       if (local_syms != NULL
8136           && symtab_hdr->contents != (unsigned char *) local_syms)
8137         {
8138           if (!info->keep_memory)
8139             free (local_syms);
8140           else
8141             symtab_hdr->contents = (unsigned char *) local_syms;
8142         }
8143     }
8144
8145   if (some_edited)
8146     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8147
8148   /* If we are doing a final link and the last .opd entry is just 16 byte
8149      long, add a 8 byte padding after it.  */
8150   if (need_pad != NULL && !bfd_link_relocatable (info))
8151     {
8152       bfd_byte *p;
8153
8154       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8155         {
8156           BFD_ASSERT (need_pad->size > 0);
8157
8158           p = bfd_malloc (need_pad->size + 8);
8159           if (p == NULL)
8160             return FALSE;
8161
8162           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8163                                           p, 0, need_pad->size))
8164             return FALSE;
8165
8166           need_pad->contents = p;
8167           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8168         }
8169       else
8170         {
8171           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8172           if (p == NULL)
8173             return FALSE;
8174
8175           need_pad->contents = p;
8176         }
8177
8178       memset (need_pad->contents + need_pad->size, 0, 8);
8179       need_pad->size += 8;
8180     }
8181
8182   return TRUE;
8183 }
8184
8185 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8186
8187 asection *
8188 ppc64_elf_tls_setup (struct bfd_link_info *info)
8189 {
8190   struct ppc_link_hash_table *htab;
8191
8192   htab = ppc_hash_table (info);
8193   if (htab == NULL)
8194     return NULL;
8195
8196   if (abiversion (info->output_bfd) == 1)
8197     htab->opd_abi = 1;
8198
8199   if (htab->params->no_multi_toc)
8200     htab->do_multi_toc = 0;
8201   else if (!htab->do_multi_toc)
8202     htab->params->no_multi_toc = 1;
8203
8204   /* Default to --no-plt-localentry, as this option can cause problems
8205      with symbol interposition.  For example, glibc libpthread.so and
8206      libc.so duplicate many pthread symbols, with a fallback
8207      implementation in libc.so.  In some cases the fallback does more
8208      work than the pthread implementation.  __pthread_condattr_destroy
8209      is one such symbol: the libpthread.so implementation is
8210      localentry:0 while the libc.so implementation is localentry:8.
8211      An app that "cleverly" uses dlopen to only load necessary
8212      libraries at runtime may omit loading libpthread.so when not
8213      running multi-threaded, which then results in the libc.so
8214      fallback symbols being used and ld.so complaining.  Now there
8215      are workarounds in ld (see non_zero_localentry) to detect the
8216      pthread situation, but that may not be the only case where
8217      --plt-localentry can cause trouble.  */
8218   if (htab->params->plt_localentry0 < 0)
8219     htab->params->plt_localentry0 = 0;
8220   if (htab->params->plt_localentry0
8221       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8222                                FALSE, FALSE, FALSE) == NULL)
8223     info->callbacks->einfo
8224       (_("%P: warning: --plt-localentry is especially dangerous without "
8225          "ld.so support to detect ABI violations.\n"));
8226
8227   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8228                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8229                                               FALSE, FALSE, TRUE));
8230   /* Move dynamic linking info to the function descriptor sym.  */
8231   if (htab->tls_get_addr != NULL)
8232     func_desc_adjust (&htab->tls_get_addr->elf, info);
8233   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8234                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8235                                                  FALSE, FALSE, TRUE));
8236   if (htab->params->tls_get_addr_opt)
8237     {
8238       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8239
8240       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8241                                   FALSE, FALSE, TRUE);
8242       if (opt != NULL)
8243         func_desc_adjust (opt, info);
8244       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8245                                      FALSE, FALSE, TRUE);
8246       if (opt_fd != NULL
8247           && (opt_fd->root.type == bfd_link_hash_defined
8248               || opt_fd->root.type == bfd_link_hash_defweak))
8249         {
8250           /* If glibc supports an optimized __tls_get_addr call stub,
8251              signalled by the presence of __tls_get_addr_opt, and we'll
8252              be calling __tls_get_addr via a plt call stub, then
8253              make __tls_get_addr point to __tls_get_addr_opt.  */
8254           tga_fd = &htab->tls_get_addr_fd->elf;
8255           if (htab->elf.dynamic_sections_created
8256               && tga_fd != NULL
8257               && (tga_fd->type == STT_FUNC
8258                   || tga_fd->needs_plt)
8259               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8260                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8261             {
8262               struct plt_entry *ent;
8263
8264               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8265                 if (ent->plt.refcount > 0)
8266                   break;
8267               if (ent != NULL)
8268                 {
8269                   tga_fd->root.type = bfd_link_hash_indirect;
8270                   tga_fd->root.u.i.link = &opt_fd->root;
8271                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8272                   opt_fd->mark = 1;
8273                   if (opt_fd->dynindx != -1)
8274                     {
8275                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8276                       opt_fd->dynindx = -1;
8277                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8278                                               opt_fd->dynstr_index);
8279                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8280                         return NULL;
8281                     }
8282                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8283                   tga = &htab->tls_get_addr->elf;
8284                   if (opt != NULL && tga != NULL)
8285                     {
8286                       tga->root.type = bfd_link_hash_indirect;
8287                       tga->root.u.i.link = &opt->root;
8288                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8289                       opt->mark = 1;
8290                       _bfd_elf_link_hash_hide_symbol (info, opt,
8291                                                       tga->forced_local);
8292                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8293                     }
8294                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8295                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8296                   if (htab->tls_get_addr != NULL)
8297                     {
8298                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8299                       htab->tls_get_addr->is_func = 1;
8300                     }
8301                 }
8302             }
8303         }
8304       else if (htab->params->tls_get_addr_opt < 0)
8305         htab->params->tls_get_addr_opt = 0;
8306     }
8307   return _bfd_elf_tls_setup (info->output_bfd, info);
8308 }
8309
8310 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8311    HASH1 or HASH2.  */
8312
8313 static bfd_boolean
8314 branch_reloc_hash_match (const bfd *ibfd,
8315                          const Elf_Internal_Rela *rel,
8316                          const struct ppc_link_hash_entry *hash1,
8317                          const struct ppc_link_hash_entry *hash2)
8318 {
8319   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8320   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8321   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8322
8323   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8324     {
8325       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8326       struct elf_link_hash_entry *h;
8327
8328       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8329       h = elf_follow_link (h);
8330       if (h == &hash1->elf || h == &hash2->elf)
8331         return TRUE;
8332     }
8333   return FALSE;
8334 }
8335
8336 /* Run through all the TLS relocs looking for optimization
8337    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8338    a preliminary section layout so that we know the TLS segment
8339    offsets.  We can't optimize earlier because some optimizations need
8340    to know the tp offset, and we need to optimize before allocating
8341    dynamic relocations.  */
8342
8343 bfd_boolean
8344 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8345 {
8346   bfd *ibfd;
8347   asection *sec;
8348   struct ppc_link_hash_table *htab;
8349   unsigned char *toc_ref;
8350   int pass;
8351
8352   if (!bfd_link_executable (info))
8353     return TRUE;
8354
8355   htab = ppc_hash_table (info);
8356   if (htab == NULL)
8357     return FALSE;
8358
8359   /* Make two passes over the relocs.  On the first pass, mark toc
8360      entries involved with tls relocs, and check that tls relocs
8361      involved in setting up a tls_get_addr call are indeed followed by
8362      such a call.  If they are not, we can't do any tls optimization.
8363      On the second pass twiddle tls_mask flags to notify
8364      relocate_section that optimization can be done, and adjust got
8365      and plt refcounts.  */
8366   toc_ref = NULL;
8367   for (pass = 0; pass < 2; ++pass)
8368     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8369       {
8370         Elf_Internal_Sym *locsyms = NULL;
8371         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8372
8373         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8374           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8375             {
8376               Elf_Internal_Rela *relstart, *rel, *relend;
8377               bfd_boolean found_tls_get_addr_arg = 0;
8378
8379               /* Read the relocations.  */
8380               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8381                                                     info->keep_memory);
8382               if (relstart == NULL)
8383                 {
8384                   free (toc_ref);
8385                   return FALSE;
8386                 }
8387
8388               relend = relstart + sec->reloc_count;
8389               for (rel = relstart; rel < relend; rel++)
8390                 {
8391                   enum elf_ppc64_reloc_type r_type;
8392                   unsigned long r_symndx;
8393                   struct elf_link_hash_entry *h;
8394                   Elf_Internal_Sym *sym;
8395                   asection *sym_sec;
8396                   unsigned char *tls_mask;
8397                   unsigned char tls_set, tls_clear, tls_type = 0;
8398                   bfd_vma value;
8399                   bfd_boolean ok_tprel, is_local;
8400                   long toc_ref_index = 0;
8401                   int expecting_tls_get_addr = 0;
8402                   bfd_boolean ret = FALSE;
8403
8404                   r_symndx = ELF64_R_SYM (rel->r_info);
8405                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8406                                   r_symndx, ibfd))
8407                     {
8408                     err_free_rel:
8409                       if (elf_section_data (sec)->relocs != relstart)
8410                         free (relstart);
8411                       if (toc_ref != NULL)
8412                         free (toc_ref);
8413                       if (locsyms != NULL
8414                           && (elf_symtab_hdr (ibfd).contents
8415                               != (unsigned char *) locsyms))
8416                         free (locsyms);
8417                       return ret;
8418                     }
8419
8420                   if (h != NULL)
8421                     {
8422                       if (h->root.type == bfd_link_hash_defined
8423                           || h->root.type == bfd_link_hash_defweak)
8424                         value = h->root.u.def.value;
8425                       else if (h->root.type == bfd_link_hash_undefweak)
8426                         value = 0;
8427                       else
8428                         {
8429                           found_tls_get_addr_arg = 0;
8430                           continue;
8431                         }
8432                     }
8433                   else
8434                     /* Symbols referenced by TLS relocs must be of type
8435                        STT_TLS.  So no need for .opd local sym adjust.  */
8436                     value = sym->st_value;
8437
8438                   ok_tprel = FALSE;
8439                   is_local = FALSE;
8440                   if (h == NULL
8441                       || !h->def_dynamic)
8442                     {
8443                       is_local = TRUE;
8444                       if (h != NULL
8445                           && h->root.type == bfd_link_hash_undefweak)
8446                         ok_tprel = TRUE;
8447                       else if (sym_sec != NULL
8448                                && sym_sec->output_section != NULL)
8449                         {
8450                           value += sym_sec->output_offset;
8451                           value += sym_sec->output_section->vma;
8452                           value -= htab->elf.tls_sec->vma;
8453                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8454                                       < (bfd_vma) 1 << 32);
8455                         }
8456                     }
8457
8458                   r_type = ELF64_R_TYPE (rel->r_info);
8459                   /* If this section has old-style __tls_get_addr calls
8460                      without marker relocs, then check that each
8461                      __tls_get_addr call reloc is preceded by a reloc
8462                      that conceivably belongs to the __tls_get_addr arg
8463                      setup insn.  If we don't find matching arg setup
8464                      relocs, don't do any tls optimization.  */
8465                   if (pass == 0
8466                       && sec->has_tls_get_addr_call
8467                       && h != NULL
8468                       && (h == &htab->tls_get_addr->elf
8469                           || h == &htab->tls_get_addr_fd->elf)
8470                       && !found_tls_get_addr_arg
8471                       && is_branch_reloc (r_type))
8472                     {
8473                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8474                                                 "TLS optimization disabled\n"),
8475                                               ibfd, sec, rel->r_offset);
8476                       ret = TRUE;
8477                       goto err_free_rel;
8478                     }
8479
8480                   found_tls_get_addr_arg = 0;
8481                   switch (r_type)
8482                     {
8483                     case R_PPC64_GOT_TLSLD16:
8484                     case R_PPC64_GOT_TLSLD16_LO:
8485                       expecting_tls_get_addr = 1;
8486                       found_tls_get_addr_arg = 1;
8487                       /* Fall through.  */
8488
8489                     case R_PPC64_GOT_TLSLD16_HI:
8490                     case R_PPC64_GOT_TLSLD16_HA:
8491                       /* These relocs should never be against a symbol
8492                          defined in a shared lib.  Leave them alone if
8493                          that turns out to be the case.  */
8494                       if (!is_local)
8495                         continue;
8496
8497                       /* LD -> LE */
8498                       tls_set = 0;
8499                       tls_clear = TLS_LD;
8500                       tls_type = TLS_TLS | TLS_LD;
8501                       break;
8502
8503                     case R_PPC64_GOT_TLSGD16:
8504                     case R_PPC64_GOT_TLSGD16_LO:
8505                       expecting_tls_get_addr = 1;
8506                       found_tls_get_addr_arg = 1;
8507                       /* Fall through. */
8508
8509                     case R_PPC64_GOT_TLSGD16_HI:
8510                     case R_PPC64_GOT_TLSGD16_HA:
8511                       if (ok_tprel)
8512                         /* GD -> LE */
8513                         tls_set = 0;
8514                       else
8515                         /* GD -> IE */
8516                         tls_set = TLS_TLS | TLS_TPRELGD;
8517                       tls_clear = TLS_GD;
8518                       tls_type = TLS_TLS | TLS_GD;
8519                       break;
8520
8521                     case R_PPC64_GOT_TPREL16_DS:
8522                     case R_PPC64_GOT_TPREL16_LO_DS:
8523                     case R_PPC64_GOT_TPREL16_HI:
8524                     case R_PPC64_GOT_TPREL16_HA:
8525                       if (ok_tprel)
8526                         {
8527                           /* IE -> LE */
8528                           tls_set = 0;
8529                           tls_clear = TLS_TPREL;
8530                           tls_type = TLS_TLS | TLS_TPREL;
8531                           break;
8532                         }
8533                       continue;
8534
8535                     case R_PPC64_TLSGD:
8536                     case R_PPC64_TLSLD:
8537                       found_tls_get_addr_arg = 1;
8538                       /* Fall through.  */
8539
8540                     case R_PPC64_TLS:
8541                     case R_PPC64_TOC16:
8542                     case R_PPC64_TOC16_LO:
8543                       if (sym_sec == NULL || sym_sec != toc)
8544                         continue;
8545
8546                       /* Mark this toc entry as referenced by a TLS
8547                          code sequence.  We can do that now in the
8548                          case of R_PPC64_TLS, and after checking for
8549                          tls_get_addr for the TOC16 relocs.  */
8550                       if (toc_ref == NULL)
8551                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8552                       if (toc_ref == NULL)
8553                         goto err_free_rel;
8554
8555                       if (h != NULL)
8556                         value = h->root.u.def.value;
8557                       else
8558                         value = sym->st_value;
8559                       value += rel->r_addend;
8560                       if (value % 8 != 0)
8561                         continue;
8562                       BFD_ASSERT (value < toc->size
8563                                   && toc->output_offset % 8 == 0);
8564                       toc_ref_index = (value + toc->output_offset) / 8;
8565                       if (r_type == R_PPC64_TLS
8566                           || r_type == R_PPC64_TLSGD
8567                           || r_type == R_PPC64_TLSLD)
8568                         {
8569                           toc_ref[toc_ref_index] = 1;
8570                           continue;
8571                         }
8572
8573                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8574                         continue;
8575
8576                       tls_set = 0;
8577                       tls_clear = 0;
8578                       expecting_tls_get_addr = 2;
8579                       break;
8580
8581                     case R_PPC64_TPREL64:
8582                       if (pass == 0
8583                           || sec != toc
8584                           || toc_ref == NULL
8585                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8586                         continue;
8587                       if (ok_tprel)
8588                         {
8589                           /* IE -> LE */
8590                           tls_set = TLS_EXPLICIT;
8591                           tls_clear = TLS_TPREL;
8592                           break;
8593                         }
8594                       continue;
8595
8596                     case R_PPC64_DTPMOD64:
8597                       if (pass == 0
8598                           || sec != toc
8599                           || toc_ref == NULL
8600                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8601                         continue;
8602                       if (rel + 1 < relend
8603                           && (rel[1].r_info
8604                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8605                           && rel[1].r_offset == rel->r_offset + 8)
8606                         {
8607                           if (ok_tprel)
8608                             /* GD -> LE */
8609                             tls_set = TLS_EXPLICIT | TLS_GD;
8610                           else
8611                             /* GD -> IE */
8612                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8613                           tls_clear = TLS_GD;
8614                         }
8615                       else
8616                         {
8617                           if (!is_local)
8618                             continue;
8619
8620                           /* LD -> LE */
8621                           tls_set = TLS_EXPLICIT;
8622                           tls_clear = TLS_LD;
8623                         }
8624                       break;
8625
8626                     default:
8627                       continue;
8628                     }
8629
8630                   if (pass == 0)
8631                     {
8632                       if (!expecting_tls_get_addr
8633                           || !sec->has_tls_get_addr_call)
8634                         continue;
8635
8636                       if (rel + 1 < relend
8637                           && branch_reloc_hash_match (ibfd, rel + 1,
8638                                                       htab->tls_get_addr,
8639                                                       htab->tls_get_addr_fd))
8640                         {
8641                           if (expecting_tls_get_addr == 2)
8642                             {
8643                               /* Check for toc tls entries.  */
8644                               unsigned char *toc_tls;
8645                               int retval;
8646
8647                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8648                                                      &locsyms,
8649                                                      rel, ibfd);
8650                               if (retval == 0)
8651                                 goto err_free_rel;
8652                               if (toc_tls != NULL)
8653                                 {
8654                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8655                                     found_tls_get_addr_arg = 1;
8656                                   if (retval > 1)
8657                                     toc_ref[toc_ref_index] = 1;
8658                                 }
8659                             }
8660                           continue;
8661                         }
8662
8663                       if (expecting_tls_get_addr != 1)
8664                         continue;
8665
8666                       /* Uh oh, we didn't find the expected call.  We
8667                          could just mark this symbol to exclude it
8668                          from tls optimization but it's safer to skip
8669                          the entire optimization.  */
8670                       /* xgettext:c-format */
8671                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8672                                                 "TLS optimization disabled\n"),
8673                                               ibfd, sec, rel->r_offset);
8674                       ret = TRUE;
8675                       goto err_free_rel;
8676                     }
8677
8678                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8679                     {
8680                       struct plt_entry *ent;
8681                       for (ent = htab->tls_get_addr->elf.plt.plist;
8682                            ent != NULL;
8683                            ent = ent->next)
8684                         if (ent->addend == 0)
8685                           {
8686                             if (ent->plt.refcount > 0)
8687                               {
8688                                 ent->plt.refcount -= 1;
8689                                 expecting_tls_get_addr = 0;
8690                               }
8691                             break;
8692                           }
8693                     }
8694
8695                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8696                     {
8697                       struct plt_entry *ent;
8698                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8699                            ent != NULL;
8700                            ent = ent->next)
8701                         if (ent->addend == 0)
8702                           {
8703                             if (ent->plt.refcount > 0)
8704                               ent->plt.refcount -= 1;
8705                             break;
8706                           }
8707                     }
8708
8709                   if (tls_clear == 0)
8710                     continue;
8711
8712                   if ((tls_set & TLS_EXPLICIT) == 0)
8713                     {
8714                       struct got_entry *ent;
8715
8716                       /* Adjust got entry for this reloc.  */
8717                       if (h != NULL)
8718                         ent = h->got.glist;
8719                       else
8720                         ent = elf_local_got_ents (ibfd)[r_symndx];
8721
8722                       for (; ent != NULL; ent = ent->next)
8723                         if (ent->addend == rel->r_addend
8724                             && ent->owner == ibfd
8725                             && ent->tls_type == tls_type)
8726                           break;
8727                       if (ent == NULL)
8728                         abort ();
8729
8730                       if (tls_set == 0)
8731                         {
8732                           /* We managed to get rid of a got entry.  */
8733                           if (ent->got.refcount > 0)
8734                             ent->got.refcount -= 1;
8735                         }
8736                     }
8737                   else
8738                     {
8739                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8740                          we'll lose one or two dyn relocs.  */
8741                       if (!dec_dynrel_count (rel->r_info, sec, info,
8742                                              NULL, h, sym))
8743                         return FALSE;
8744
8745                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8746                         {
8747                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8748                                                  NULL, h, sym))
8749                             return FALSE;
8750                         }
8751                     }
8752
8753                   *tls_mask |= tls_set;
8754                   *tls_mask &= ~tls_clear;
8755                 }
8756
8757               if (elf_section_data (sec)->relocs != relstart)
8758                 free (relstart);
8759             }
8760
8761         if (locsyms != NULL
8762             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8763           {
8764             if (!info->keep_memory)
8765               free (locsyms);
8766             else
8767               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8768           }
8769       }
8770
8771   if (toc_ref != NULL)
8772     free (toc_ref);
8773   htab->do_tls_opt = 1;
8774   return TRUE;
8775 }
8776
8777 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8778    the values of any global symbols in a toc section that has been
8779    edited.  Globals in toc sections should be a rarity, so this function
8780    sets a flag if any are found in toc sections other than the one just
8781    edited, so that further hash table traversals can be avoided.  */
8782
8783 struct adjust_toc_info
8784 {
8785   asection *toc;
8786   unsigned long *skip;
8787   bfd_boolean global_toc_syms;
8788 };
8789
8790 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8791
8792 static bfd_boolean
8793 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8794 {
8795   struct ppc_link_hash_entry *eh;
8796   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8797   unsigned long i;
8798
8799   if (h->root.type != bfd_link_hash_defined
8800       && h->root.type != bfd_link_hash_defweak)
8801     return TRUE;
8802
8803   eh = (struct ppc_link_hash_entry *) h;
8804   if (eh->adjust_done)
8805     return TRUE;
8806
8807   if (eh->elf.root.u.def.section == toc_inf->toc)
8808     {
8809       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8810         i = toc_inf->toc->rawsize >> 3;
8811       else
8812         i = eh->elf.root.u.def.value >> 3;
8813
8814       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8815         {
8816           _bfd_error_handler
8817             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8818           do
8819             ++i;
8820           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8821           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8822         }
8823
8824       eh->elf.root.u.def.value -= toc_inf->skip[i];
8825       eh->adjust_done = 1;
8826     }
8827   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8828     toc_inf->global_toc_syms = TRUE;
8829
8830   return TRUE;
8831 }
8832
8833 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8834    on a _LO variety toc/got reloc.  */
8835
8836 static bfd_boolean
8837 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8838 {
8839   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8840           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8841           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8842           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8843           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8844           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8845           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8846           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8847           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8848           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8849           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8850           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8851           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8852           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8853           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8854           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8855           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8856               /* Exclude lfqu by testing reloc.  If relocs are ever
8857                  defined for the reduced D field in psq_lu then those
8858                  will need testing too.  */
8859               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8860           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8861               && (insn & 1) == 0)
8862           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8863           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8864               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8865               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8866           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8867               && (insn & 1) == 0));
8868 }
8869
8870 /* Examine all relocs referencing .toc sections in order to remove
8871    unused .toc entries.  */
8872
8873 bfd_boolean
8874 ppc64_elf_edit_toc (struct bfd_link_info *info)
8875 {
8876   bfd *ibfd;
8877   struct adjust_toc_info toc_inf;
8878   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8879
8880   htab->do_toc_opt = 1;
8881   toc_inf.global_toc_syms = TRUE;
8882   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8883     {
8884       asection *toc, *sec;
8885       Elf_Internal_Shdr *symtab_hdr;
8886       Elf_Internal_Sym *local_syms;
8887       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8888       unsigned long *skip, *drop;
8889       unsigned char *used;
8890       unsigned char *keep, last, some_unused;
8891
8892       if (!is_ppc64_elf (ibfd))
8893         continue;
8894
8895       toc = bfd_get_section_by_name (ibfd, ".toc");
8896       if (toc == NULL
8897           || toc->size == 0
8898           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8899           || discarded_section (toc))
8900         continue;
8901
8902       toc_relocs = NULL;
8903       local_syms = NULL;
8904       symtab_hdr = &elf_symtab_hdr (ibfd);
8905
8906       /* Look at sections dropped from the final link.  */
8907       skip = NULL;
8908       relstart = NULL;
8909       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8910         {
8911           if (sec->reloc_count == 0
8912               || !discarded_section (sec)
8913               || get_opd_info (sec)
8914               || (sec->flags & SEC_ALLOC) == 0
8915               || (sec->flags & SEC_DEBUGGING) != 0)
8916             continue;
8917
8918           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8919           if (relstart == NULL)
8920             goto error_ret;
8921
8922           /* Run through the relocs to see which toc entries might be
8923              unused.  */
8924           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8925             {
8926               enum elf_ppc64_reloc_type r_type;
8927               unsigned long r_symndx;
8928               asection *sym_sec;
8929               struct elf_link_hash_entry *h;
8930               Elf_Internal_Sym *sym;
8931               bfd_vma val;
8932
8933               r_type = ELF64_R_TYPE (rel->r_info);
8934               switch (r_type)
8935                 {
8936                 default:
8937                   continue;
8938
8939                 case R_PPC64_TOC16:
8940                 case R_PPC64_TOC16_LO:
8941                 case R_PPC64_TOC16_HI:
8942                 case R_PPC64_TOC16_HA:
8943                 case R_PPC64_TOC16_DS:
8944                 case R_PPC64_TOC16_LO_DS:
8945                   break;
8946                 }
8947
8948               r_symndx = ELF64_R_SYM (rel->r_info);
8949               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8950                               r_symndx, ibfd))
8951                 goto error_ret;
8952
8953               if (sym_sec != toc)
8954                 continue;
8955
8956               if (h != NULL)
8957                 val = h->root.u.def.value;
8958               else
8959                 val = sym->st_value;
8960               val += rel->r_addend;
8961
8962               if (val >= toc->size)
8963                 continue;
8964
8965               /* Anything in the toc ought to be aligned to 8 bytes.
8966                  If not, don't mark as unused.  */
8967               if (val & 7)
8968                 continue;
8969
8970               if (skip == NULL)
8971                 {
8972                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8973                   if (skip == NULL)
8974                     goto error_ret;
8975                 }
8976
8977               skip[val >> 3] = ref_from_discarded;
8978             }
8979
8980           if (elf_section_data (sec)->relocs != relstart)
8981             free (relstart);
8982         }
8983
8984       /* For largetoc loads of address constants, we can convert
8985          .  addis rx,2,addr@got@ha
8986          .  ld ry,addr@got@l(rx)
8987          to
8988          .  addis rx,2,addr@toc@ha
8989          .  addi ry,rx,addr@toc@l
8990          when addr is within 2G of the toc pointer.  This then means
8991          that the word storing "addr" in the toc is no longer needed.  */
8992
8993       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8994           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8995           && toc->reloc_count != 0)
8996         {
8997           /* Read toc relocs.  */
8998           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8999                                                   info->keep_memory);
9000           if (toc_relocs == NULL)
9001             goto error_ret;
9002
9003           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9004             {
9005               enum elf_ppc64_reloc_type r_type;
9006               unsigned long r_symndx;
9007               asection *sym_sec;
9008               struct elf_link_hash_entry *h;
9009               Elf_Internal_Sym *sym;
9010               bfd_vma val, addr;
9011
9012               r_type = ELF64_R_TYPE (rel->r_info);
9013               if (r_type != R_PPC64_ADDR64)
9014                 continue;
9015
9016               r_symndx = ELF64_R_SYM (rel->r_info);
9017               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9018                               r_symndx, ibfd))
9019                 goto error_ret;
9020
9021               if (sym_sec == NULL
9022                   || sym_sec->output_section == NULL
9023                   || discarded_section (sym_sec))
9024                 continue;
9025
9026               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9027                 continue;
9028
9029               if (h != NULL)
9030                 {
9031                   if (h->type == STT_GNU_IFUNC)
9032                     continue;
9033                   val = h->root.u.def.value;
9034                 }
9035               else
9036                 {
9037                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9038                     continue;
9039                   val = sym->st_value;
9040                 }
9041               val += rel->r_addend;
9042               val += sym_sec->output_section->vma + sym_sec->output_offset;
9043
9044               /* We don't yet know the exact toc pointer value, but we
9045                  know it will be somewhere in the toc section.  Don't
9046                  optimize if the difference from any possible toc
9047                  pointer is outside [ff..f80008000, 7fff7fff].  */
9048               addr = toc->output_section->vma + TOC_BASE_OFF;
9049               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9050                 continue;
9051
9052               addr = toc->output_section->vma + toc->output_section->rawsize;
9053               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9054                 continue;
9055
9056               if (skip == NULL)
9057                 {
9058                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9059                   if (skip == NULL)
9060                     goto error_ret;
9061                 }
9062
9063               skip[rel->r_offset >> 3]
9064                 |= can_optimize | ((rel - toc_relocs) << 2);
9065             }
9066         }
9067
9068       if (skip == NULL)
9069         continue;
9070
9071       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9072       if (used == NULL)
9073         {
9074         error_ret:
9075           if (local_syms != NULL
9076               && symtab_hdr->contents != (unsigned char *) local_syms)
9077             free (local_syms);
9078           if (sec != NULL
9079               && relstart != NULL
9080               && elf_section_data (sec)->relocs != relstart)
9081             free (relstart);
9082           if (toc_relocs != NULL
9083               && elf_section_data (toc)->relocs != toc_relocs)
9084             free (toc_relocs);
9085           if (skip != NULL)
9086             free (skip);
9087           return FALSE;
9088         }
9089
9090       /* Now check all kept sections that might reference the toc.
9091          Check the toc itself last.  */
9092       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9093                   : ibfd->sections);
9094            sec != NULL;
9095            sec = (sec == toc ? NULL
9096                   : sec->next == NULL ? toc
9097                   : sec->next == toc && toc->next ? toc->next
9098                   : sec->next))
9099         {
9100           int repeat;
9101
9102           if (sec->reloc_count == 0
9103               || discarded_section (sec)
9104               || get_opd_info (sec)
9105               || (sec->flags & SEC_ALLOC) == 0
9106               || (sec->flags & SEC_DEBUGGING) != 0)
9107             continue;
9108
9109           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9110                                                 info->keep_memory);
9111           if (relstart == NULL)
9112             {
9113               free (used);
9114               goto error_ret;
9115             }
9116
9117           /* Mark toc entries referenced as used.  */
9118           do
9119             {
9120               repeat = 0;
9121               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9122                 {
9123                   enum elf_ppc64_reloc_type r_type;
9124                   unsigned long r_symndx;
9125                   asection *sym_sec;
9126                   struct elf_link_hash_entry *h;
9127                   Elf_Internal_Sym *sym;
9128                   bfd_vma val;
9129                   enum {no_check, check_lo, check_ha} insn_check;
9130
9131                   r_type = ELF64_R_TYPE (rel->r_info);
9132                   switch (r_type)
9133                     {
9134                     default:
9135                       insn_check = no_check;
9136                       break;
9137
9138                     case R_PPC64_GOT_TLSLD16_HA:
9139                     case R_PPC64_GOT_TLSGD16_HA:
9140                     case R_PPC64_GOT_TPREL16_HA:
9141                     case R_PPC64_GOT_DTPREL16_HA:
9142                     case R_PPC64_GOT16_HA:
9143                     case R_PPC64_TOC16_HA:
9144                       insn_check = check_ha;
9145                       break;
9146
9147                     case R_PPC64_GOT_TLSLD16_LO:
9148                     case R_PPC64_GOT_TLSGD16_LO:
9149                     case R_PPC64_GOT_TPREL16_LO_DS:
9150                     case R_PPC64_GOT_DTPREL16_LO_DS:
9151                     case R_PPC64_GOT16_LO:
9152                     case R_PPC64_GOT16_LO_DS:
9153                     case R_PPC64_TOC16_LO:
9154                     case R_PPC64_TOC16_LO_DS:
9155                       insn_check = check_lo;
9156                       break;
9157                     }
9158
9159                   if (insn_check != no_check)
9160                     {
9161                       bfd_vma off = rel->r_offset & ~3;
9162                       unsigned char buf[4];
9163                       unsigned int insn;
9164
9165                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9166                         {
9167                           free (used);
9168                           goto error_ret;
9169                         }
9170                       insn = bfd_get_32 (ibfd, buf);
9171                       if (insn_check == check_lo
9172                           ? !ok_lo_toc_insn (insn, r_type)
9173                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9174                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9175                         {
9176                           char str[12];
9177
9178                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9179                           sprintf (str, "%#08x", insn);
9180                           info->callbacks->einfo
9181                             /* xgettext:c-format */
9182                             (_("%H: toc optimization is not supported for"
9183                                " %s instruction.\n"),
9184                              ibfd, sec, rel->r_offset & ~3, str);
9185                         }
9186                     }
9187
9188                   switch (r_type)
9189                     {
9190                     case R_PPC64_TOC16:
9191                     case R_PPC64_TOC16_LO:
9192                     case R_PPC64_TOC16_HI:
9193                     case R_PPC64_TOC16_HA:
9194                     case R_PPC64_TOC16_DS:
9195                     case R_PPC64_TOC16_LO_DS:
9196                       /* In case we're taking addresses of toc entries.  */
9197                     case R_PPC64_ADDR64:
9198                       break;
9199
9200                     default:
9201                       continue;
9202                     }
9203
9204                   r_symndx = ELF64_R_SYM (rel->r_info);
9205                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9206                                   r_symndx, ibfd))
9207                     {
9208                       free (used);
9209                       goto error_ret;
9210                     }
9211
9212                   if (sym_sec != toc)
9213                     continue;
9214
9215                   if (h != NULL)
9216                     val = h->root.u.def.value;
9217                   else
9218                     val = sym->st_value;
9219                   val += rel->r_addend;
9220
9221                   if (val >= toc->size)
9222                     continue;
9223
9224                   if ((skip[val >> 3] & can_optimize) != 0)
9225                     {
9226                       bfd_vma off;
9227                       unsigned char opc;
9228
9229                       switch (r_type)
9230                         {
9231                         case R_PPC64_TOC16_HA:
9232                           break;
9233
9234                         case R_PPC64_TOC16_LO_DS:
9235                           off = rel->r_offset;
9236                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9237                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9238                                                          off, 1))
9239                             {
9240                               free (used);
9241                               goto error_ret;
9242                             }
9243                           if ((opc & (0x3f << 2)) == (58u << 2))
9244                             break;
9245                           /* Fall through.  */
9246
9247                         default:
9248                           /* Wrong sort of reloc, or not a ld.  We may
9249                              as well clear ref_from_discarded too.  */
9250                           skip[val >> 3] = 0;
9251                         }
9252                     }
9253
9254                   if (sec != toc)
9255                     used[val >> 3] = 1;
9256                   /* For the toc section, we only mark as used if this
9257                      entry itself isn't unused.  */
9258                   else if ((used[rel->r_offset >> 3]
9259                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9260                            && !used[val >> 3])
9261                     {
9262                       /* Do all the relocs again, to catch reference
9263                          chains.  */
9264                       repeat = 1;
9265                       used[val >> 3] = 1;
9266                     }
9267                 }
9268             }
9269           while (repeat);
9270
9271           if (elf_section_data (sec)->relocs != relstart)
9272             free (relstart);
9273         }
9274
9275       /* Merge the used and skip arrays.  Assume that TOC
9276          doublewords not appearing as either used or unused belong
9277          to an entry more than one doubleword in size.  */
9278       for (drop = skip, keep = used, last = 0, some_unused = 0;
9279            drop < skip + (toc->size + 7) / 8;
9280            ++drop, ++keep)
9281         {
9282           if (*keep)
9283             {
9284               *drop &= ~ref_from_discarded;
9285               if ((*drop & can_optimize) != 0)
9286                 some_unused = 1;
9287               last = 0;
9288             }
9289           else if ((*drop & ref_from_discarded) != 0)
9290             {
9291               some_unused = 1;
9292               last = ref_from_discarded;
9293             }
9294           else
9295             *drop = last;
9296         }
9297
9298       free (used);
9299
9300       if (some_unused)
9301         {
9302           bfd_byte *contents, *src;
9303           unsigned long off;
9304           Elf_Internal_Sym *sym;
9305           bfd_boolean local_toc_syms = FALSE;
9306
9307           /* Shuffle the toc contents, and at the same time convert the
9308              skip array from booleans into offsets.  */
9309           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9310             goto error_ret;
9311
9312           elf_section_data (toc)->this_hdr.contents = contents;
9313
9314           for (src = contents, off = 0, drop = skip;
9315                src < contents + toc->size;
9316                src += 8, ++drop)
9317             {
9318               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9319                 off += 8;
9320               else if (off != 0)
9321                 {
9322                   *drop = off;
9323                   memcpy (src - off, src, 8);
9324                 }
9325             }
9326           *drop = off;
9327           toc->rawsize = toc->size;
9328           toc->size = src - contents - off;
9329
9330           /* Adjust addends for relocs against the toc section sym,
9331              and optimize any accesses we can.  */
9332           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9333             {
9334               if (sec->reloc_count == 0
9335                   || discarded_section (sec))
9336                 continue;
9337
9338               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9339                                                     info->keep_memory);
9340               if (relstart == NULL)
9341                 goto error_ret;
9342
9343               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9344                 {
9345                   enum elf_ppc64_reloc_type r_type;
9346                   unsigned long r_symndx;
9347                   asection *sym_sec;
9348                   struct elf_link_hash_entry *h;
9349                   bfd_vma val;
9350
9351                   r_type = ELF64_R_TYPE (rel->r_info);
9352                   switch (r_type)
9353                     {
9354                     default:
9355                       continue;
9356
9357                     case R_PPC64_TOC16:
9358                     case R_PPC64_TOC16_LO:
9359                     case R_PPC64_TOC16_HI:
9360                     case R_PPC64_TOC16_HA:
9361                     case R_PPC64_TOC16_DS:
9362                     case R_PPC64_TOC16_LO_DS:
9363                     case R_PPC64_ADDR64:
9364                       break;
9365                     }
9366
9367                   r_symndx = ELF64_R_SYM (rel->r_info);
9368                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9369                                   r_symndx, ibfd))
9370                     goto error_ret;
9371
9372                   if (sym_sec != toc)
9373                     continue;
9374
9375                   if (h != NULL)
9376                     val = h->root.u.def.value;
9377                   else
9378                     {
9379                       val = sym->st_value;
9380                       if (val != 0)
9381                         local_toc_syms = TRUE;
9382                     }
9383
9384                   val += rel->r_addend;
9385
9386                   if (val > toc->rawsize)
9387                     val = toc->rawsize;
9388                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9389                     continue;
9390                   else if ((skip[val >> 3] & can_optimize) != 0)
9391                     {
9392                       Elf_Internal_Rela *tocrel
9393                         = toc_relocs + (skip[val >> 3] >> 2);
9394                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9395
9396                       switch (r_type)
9397                         {
9398                         case R_PPC64_TOC16_HA:
9399                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9400                           break;
9401
9402                         case R_PPC64_TOC16_LO_DS:
9403                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9404                           break;
9405
9406                         default:
9407                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9408                             ppc_howto_init ();
9409                           info->callbacks->einfo
9410                             /* xgettext:c-format */
9411                             (_("%H: %s references "
9412                                "optimized away TOC entry\n"),
9413                              ibfd, sec, rel->r_offset,
9414                              ppc64_elf_howto_table[r_type]->name);
9415                           bfd_set_error (bfd_error_bad_value);
9416                           goto error_ret;
9417                         }
9418                       rel->r_addend = tocrel->r_addend;
9419                       elf_section_data (sec)->relocs = relstart;
9420                       continue;
9421                     }
9422
9423                   if (h != NULL || sym->st_value != 0)
9424                     continue;
9425
9426                   rel->r_addend -= skip[val >> 3];
9427                   elf_section_data (sec)->relocs = relstart;
9428                 }
9429
9430               if (elf_section_data (sec)->relocs != relstart)
9431                 free (relstart);
9432             }
9433
9434           /* We shouldn't have local or global symbols defined in the TOC,
9435              but handle them anyway.  */
9436           if (local_syms != NULL)
9437             for (sym = local_syms;
9438                  sym < local_syms + symtab_hdr->sh_info;
9439                  ++sym)
9440               if (sym->st_value != 0
9441                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9442                 {
9443                   unsigned long i;
9444
9445                   if (sym->st_value > toc->rawsize)
9446                     i = toc->rawsize >> 3;
9447                   else
9448                     i = sym->st_value >> 3;
9449
9450                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9451                     {
9452                       if (local_toc_syms)
9453                         _bfd_error_handler
9454                           (_("%s defined on removed toc entry"),
9455                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9456                       do
9457                         ++i;
9458                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9459                       sym->st_value = (bfd_vma) i << 3;
9460                     }
9461
9462                   sym->st_value -= skip[i];
9463                   symtab_hdr->contents = (unsigned char *) local_syms;
9464                 }
9465
9466           /* Adjust any global syms defined in this toc input section.  */
9467           if (toc_inf.global_toc_syms)
9468             {
9469               toc_inf.toc = toc;
9470               toc_inf.skip = skip;
9471               toc_inf.global_toc_syms = FALSE;
9472               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9473                                       &toc_inf);
9474             }
9475
9476           if (toc->reloc_count != 0)
9477             {
9478               Elf_Internal_Shdr *rel_hdr;
9479               Elf_Internal_Rela *wrel;
9480               bfd_size_type sz;
9481
9482               /* Remove unused toc relocs, and adjust those we keep.  */
9483               if (toc_relocs == NULL)
9484                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9485                                                         info->keep_memory);
9486               if (toc_relocs == NULL)
9487                 goto error_ret;
9488
9489               wrel = toc_relocs;
9490               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9491                 if ((skip[rel->r_offset >> 3]
9492                      & (ref_from_discarded | can_optimize)) == 0)
9493                   {
9494                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9495                     wrel->r_info = rel->r_info;
9496                     wrel->r_addend = rel->r_addend;
9497                     ++wrel;
9498                   }
9499                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9500                                             &local_syms, NULL, NULL))
9501                   goto error_ret;
9502
9503               elf_section_data (toc)->relocs = toc_relocs;
9504               toc->reloc_count = wrel - toc_relocs;
9505               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9506               sz = rel_hdr->sh_entsize;
9507               rel_hdr->sh_size = toc->reloc_count * sz;
9508             }
9509         }
9510       else if (toc_relocs != NULL
9511                && elf_section_data (toc)->relocs != toc_relocs)
9512         free (toc_relocs);
9513
9514       if (local_syms != NULL
9515           && symtab_hdr->contents != (unsigned char *) local_syms)
9516         {
9517           if (!info->keep_memory)
9518             free (local_syms);
9519           else
9520             symtab_hdr->contents = (unsigned char *) local_syms;
9521         }
9522       free (skip);
9523     }
9524
9525   return TRUE;
9526 }
9527
9528 /* Return true iff input section I references the TOC using
9529    instructions limited to +/-32k offsets.  */
9530
9531 bfd_boolean
9532 ppc64_elf_has_small_toc_reloc (asection *i)
9533 {
9534   return (is_ppc64_elf (i->owner)
9535           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9536 }
9537
9538 /* Allocate space for one GOT entry.  */
9539
9540 static void
9541 allocate_got (struct elf_link_hash_entry *h,
9542               struct bfd_link_info *info,
9543               struct got_entry *gent)
9544 {
9545   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9546   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9547   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9548                  ? 16 : 8);
9549   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9550                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9551   asection *got = ppc64_elf_tdata (gent->owner)->got;
9552
9553   gent->got.offset = got->size;
9554   got->size += entsize;
9555
9556   if (h->type == STT_GNU_IFUNC)
9557     {
9558       htab->elf.irelplt->size += rentsize;
9559       htab->got_reli_size += rentsize;
9560     }
9561   else if (((bfd_link_pic (info)
9562              && !((gent->tls_type & TLS_TPREL) != 0
9563                   && bfd_link_executable (info)
9564                   && SYMBOL_REFERENCES_LOCAL (info, h)))
9565             || (htab->elf.dynamic_sections_created
9566                 && h->dynindx != -1
9567                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9568            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9569     {
9570       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9571       relgot->size += rentsize;
9572     }
9573 }
9574
9575 /* This function merges got entries in the same toc group.  */
9576
9577 static void
9578 merge_got_entries (struct got_entry **pent)
9579 {
9580   struct got_entry *ent, *ent2;
9581
9582   for (ent = *pent; ent != NULL; ent = ent->next)
9583     if (!ent->is_indirect)
9584       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9585         if (!ent2->is_indirect
9586             && ent2->addend == ent->addend
9587             && ent2->tls_type == ent->tls_type
9588             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9589           {
9590             ent2->is_indirect = TRUE;
9591             ent2->got.ent = ent;
9592           }
9593 }
9594
9595 /* If H is undefined, make it dynamic if that makes sense.  */
9596
9597 static bfd_boolean
9598 ensure_undef_dynamic (struct bfd_link_info *info,
9599                       struct elf_link_hash_entry *h)
9600 {
9601   struct elf_link_hash_table *htab = elf_hash_table (info);
9602
9603   if (htab->dynamic_sections_created
9604       && ((info->dynamic_undefined_weak != 0
9605            && h->root.type == bfd_link_hash_undefweak)
9606           || h->root.type == bfd_link_hash_undefined)
9607       && h->dynindx == -1
9608       && !h->forced_local
9609       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9610     return bfd_elf_link_record_dynamic_symbol (info, h);
9611   return TRUE;
9612 }
9613
9614 /* Allocate space in .plt, .got and associated reloc sections for
9615    dynamic relocs.  */
9616
9617 static bfd_boolean
9618 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9619 {
9620   struct bfd_link_info *info;
9621   struct ppc_link_hash_table *htab;
9622   asection *s;
9623   struct ppc_link_hash_entry *eh;
9624   struct got_entry **pgent, *gent;
9625
9626   if (h->root.type == bfd_link_hash_indirect)
9627     return TRUE;
9628
9629   info = (struct bfd_link_info *) inf;
9630   htab = ppc_hash_table (info);
9631   if (htab == NULL)
9632     return FALSE;
9633
9634   eh = (struct ppc_link_hash_entry *) h;
9635   /* Run through the TLS GD got entries first if we're changing them
9636      to TPREL.  */
9637   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9638     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9639       if (gent->got.refcount > 0
9640           && (gent->tls_type & TLS_GD) != 0)
9641         {
9642           /* This was a GD entry that has been converted to TPREL.  If
9643              there happens to be a TPREL entry we can use that one.  */
9644           struct got_entry *ent;
9645           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9646             if (ent->got.refcount > 0
9647                 && (ent->tls_type & TLS_TPREL) != 0
9648                 && ent->addend == gent->addend
9649                 && ent->owner == gent->owner)
9650               {
9651                 gent->got.refcount = 0;
9652                 break;
9653               }
9654
9655           /* If not, then we'll be using our own TPREL entry.  */
9656           if (gent->got.refcount != 0)
9657             gent->tls_type = TLS_TLS | TLS_TPREL;
9658         }
9659
9660   /* Remove any list entry that won't generate a word in the GOT before
9661      we call merge_got_entries.  Otherwise we risk merging to empty
9662      entries.  */
9663   pgent = &h->got.glist;
9664   while ((gent = *pgent) != NULL)
9665     if (gent->got.refcount > 0)
9666       {
9667         if ((gent->tls_type & TLS_LD) != 0
9668             && !h->def_dynamic)
9669           {
9670             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9671             *pgent = gent->next;
9672           }
9673         else
9674           pgent = &gent->next;
9675       }
9676     else
9677       *pgent = gent->next;
9678
9679   if (!htab->do_multi_toc)
9680     merge_got_entries (&h->got.glist);
9681
9682   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9683     if (!gent->is_indirect)
9684       {
9685         /* Make sure this symbol is output as a dynamic symbol.  */
9686         if (!ensure_undef_dynamic (info, h))
9687           return FALSE;
9688
9689         if (!is_ppc64_elf (gent->owner))
9690           abort ();
9691
9692         allocate_got (h, info, gent);
9693       }
9694
9695   /* If no dynamic sections we can't have dynamic relocs, except for
9696      IFUNCs which are handled even in static executables.  */
9697   if (!htab->elf.dynamic_sections_created
9698       && h->type != STT_GNU_IFUNC)
9699     eh->dyn_relocs = NULL;
9700
9701   /* Discard relocs on undefined symbols that must be local.  */
9702   else if (h->root.type == bfd_link_hash_undefined
9703            && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9704     eh->dyn_relocs = NULL;
9705
9706   /* Also discard relocs on undefined weak syms with non-default
9707      visibility, or when dynamic_undefined_weak says so.  */
9708   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9709     eh->dyn_relocs = NULL;
9710
9711   if (eh->dyn_relocs != NULL)
9712     {
9713       struct elf_dyn_relocs *p, **pp;
9714
9715       /* In the shared -Bsymbolic case, discard space allocated for
9716          dynamic pc-relative relocs against symbols which turn out to
9717          be defined in regular objects.  For the normal shared case,
9718          discard space for relocs that have become local due to symbol
9719          visibility changes.  */
9720
9721       if (bfd_link_pic (info))
9722         {
9723           /* Relocs that use pc_count are those that appear on a call
9724              insn, or certain REL relocs (see must_be_dyn_reloc) that
9725              can be generated via assembly.  We want calls to
9726              protected symbols to resolve directly to the function
9727              rather than going via the plt.  If people want function
9728              pointer comparisons to work as expected then they should
9729              avoid writing weird assembly.  */
9730           if (SYMBOL_CALLS_LOCAL (info, h))
9731             {
9732               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9733                 {
9734                   p->count -= p->pc_count;
9735                   p->pc_count = 0;
9736                   if (p->count == 0)
9737                     *pp = p->next;
9738                   else
9739                     pp = &p->next;
9740                 }
9741             }
9742
9743           if (eh->dyn_relocs != NULL)
9744             {
9745               /* Make sure this symbol is output as a dynamic symbol.  */
9746               if (!ensure_undef_dynamic (info, h))
9747                 return FALSE;
9748             }
9749         }
9750       else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9751         {
9752           /* For the non-pic case, discard space for relocs against
9753              symbols which turn out to need copy relocs or are not
9754              dynamic.  */
9755           if (h->dynamic_adjusted
9756               && !h->def_regular
9757               && !ELF_COMMON_DEF_P (h))
9758             {
9759               /* Make sure this symbol is output as a dynamic symbol.  */
9760               if (!ensure_undef_dynamic (info, h))
9761                 return FALSE;
9762
9763               if (h->dynindx == -1)
9764                 eh->dyn_relocs = NULL;
9765             }
9766           else
9767             eh->dyn_relocs = NULL;
9768         }
9769
9770       /* Finally, allocate space.  */
9771       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9772         {
9773           asection *sreloc = elf_section_data (p->sec)->sreloc;
9774           if (eh->elf.type == STT_GNU_IFUNC)
9775             sreloc = htab->elf.irelplt;
9776           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9777         }
9778     }
9779
9780   if ((htab->elf.dynamic_sections_created
9781        && h->dynindx != -1)
9782       || h->type == STT_GNU_IFUNC)
9783     {
9784       struct plt_entry *pent;
9785       bfd_boolean doneone = FALSE;
9786       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9787         if (pent->plt.refcount > 0)
9788           {
9789             if (!htab->elf.dynamic_sections_created
9790                 || h->dynindx == -1)
9791               {
9792                 s = htab->elf.iplt;
9793                 pent->plt.offset = s->size;
9794                 s->size += PLT_ENTRY_SIZE (htab);
9795                 s = htab->elf.irelplt;
9796               }
9797             else
9798               {
9799                 /* If this is the first .plt entry, make room for the special
9800                    first entry.  */
9801                 s = htab->elf.splt;
9802                 if (s->size == 0)
9803                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9804
9805                 pent->plt.offset = s->size;
9806
9807                 /* Make room for this entry.  */
9808                 s->size += PLT_ENTRY_SIZE (htab);
9809
9810                 /* Make room for the .glink code.  */
9811                 s = htab->glink;
9812                 if (s->size == 0)
9813                   s->size += GLINK_CALL_STUB_SIZE;
9814                 if (htab->opd_abi)
9815                   {
9816                     /* We need bigger stubs past index 32767.  */
9817                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9818                       s->size += 4;
9819                     s->size += 2*4;
9820                   }
9821                 else
9822                   s->size += 4;
9823
9824                 /* We also need to make an entry in the .rela.plt section.  */
9825                 s = htab->elf.srelplt;
9826               }
9827             s->size += sizeof (Elf64_External_Rela);
9828             doneone = TRUE;
9829           }
9830         else
9831           pent->plt.offset = (bfd_vma) -1;
9832       if (!doneone)
9833         {
9834           h->plt.plist = NULL;
9835           h->needs_plt = 0;
9836         }
9837     }
9838   else
9839     {
9840       h->plt.plist = NULL;
9841       h->needs_plt = 0;
9842     }
9843
9844   return TRUE;
9845 }
9846
9847 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9848    to set up space for global entry stubs.  These are put in glink,
9849    after the branch table.  */
9850
9851 static bfd_boolean
9852 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9853 {
9854   struct bfd_link_info *info;
9855   struct ppc_link_hash_table *htab;
9856   struct plt_entry *pent;
9857   asection *s;
9858
9859   if (h->root.type == bfd_link_hash_indirect)
9860     return TRUE;
9861
9862   if (!h->pointer_equality_needed)
9863     return TRUE;
9864
9865   if (h->def_regular)
9866     return TRUE;
9867
9868   info = inf;
9869   htab = ppc_hash_table (info);
9870   if (htab == NULL)
9871     return FALSE;
9872
9873   s = htab->glink;
9874   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9875     if (pent->plt.offset != (bfd_vma) -1
9876         && pent->addend == 0)
9877       {
9878         /* For ELFv2, if this symbol is not defined in a regular file
9879            and we are not generating a shared library or pie, then we
9880            need to define the symbol in the executable on a call stub.
9881            This is to avoid text relocations.  */
9882         s->size = (s->size + 15) & -16;
9883         h->root.type = bfd_link_hash_defined;
9884         h->root.u.def.section = s;
9885         h->root.u.def.value = s->size;
9886         s->size += 16;
9887         break;
9888       }
9889   return TRUE;
9890 }
9891
9892 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9893    read-only sections.  */
9894
9895 static bfd_boolean
9896 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9897 {
9898   asection *sec;
9899
9900   if (h->root.type == bfd_link_hash_indirect)
9901     return TRUE;
9902
9903   sec = readonly_dynrelocs (h);
9904   if (sec != NULL)
9905     {
9906       struct bfd_link_info *info = (struct bfd_link_info *) inf;
9907
9908       info->flags |= DF_TEXTREL;
9909       info->callbacks->minfo
9910         (_("%B: dynamic relocation in read-only section `%A'\n"),
9911          sec->owner, sec);
9912
9913       /* Not an error, just cut short the traversal.  */
9914       return FALSE;
9915     }
9916   return TRUE;
9917 }
9918
9919 /* Set the sizes of the dynamic sections.  */
9920
9921 static bfd_boolean
9922 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9923                                  struct bfd_link_info *info)
9924 {
9925   struct ppc_link_hash_table *htab;
9926   bfd *dynobj;
9927   asection *s;
9928   bfd_boolean relocs;
9929   bfd *ibfd;
9930   struct got_entry *first_tlsld;
9931
9932   htab = ppc_hash_table (info);
9933   if (htab == NULL)
9934     return FALSE;
9935
9936   dynobj = htab->elf.dynobj;
9937   if (dynobj == NULL)
9938     abort ();
9939
9940   if (htab->elf.dynamic_sections_created)
9941     {
9942       /* Set the contents of the .interp section to the interpreter.  */
9943       if (bfd_link_executable (info) && !info->nointerp)
9944         {
9945           s = bfd_get_linker_section (dynobj, ".interp");
9946           if (s == NULL)
9947             abort ();
9948           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9949           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9950         }
9951     }
9952
9953   /* Set up .got offsets for local syms, and space for local dynamic
9954      relocs.  */
9955   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9956     {
9957       struct got_entry **lgot_ents;
9958       struct got_entry **end_lgot_ents;
9959       struct plt_entry **local_plt;
9960       struct plt_entry **end_local_plt;
9961       unsigned char *lgot_masks;
9962       bfd_size_type locsymcount;
9963       Elf_Internal_Shdr *symtab_hdr;
9964
9965       if (!is_ppc64_elf (ibfd))
9966         continue;
9967
9968       for (s = ibfd->sections; s != NULL; s = s->next)
9969         {
9970           struct ppc_dyn_relocs *p;
9971
9972           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9973             {
9974               if (!bfd_is_abs_section (p->sec)
9975                   && bfd_is_abs_section (p->sec->output_section))
9976                 {
9977                   /* Input section has been discarded, either because
9978                      it is a copy of a linkonce section or due to
9979                      linker script /DISCARD/, so we'll be discarding
9980                      the relocs too.  */
9981                 }
9982               else if (p->count != 0)
9983                 {
9984                   asection *srel = elf_section_data (p->sec)->sreloc;
9985                   if (p->ifunc)
9986                     srel = htab->elf.irelplt;
9987                   srel->size += p->count * sizeof (Elf64_External_Rela);
9988                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9989                     info->flags |= DF_TEXTREL;
9990                 }
9991             }
9992         }
9993
9994       lgot_ents = elf_local_got_ents (ibfd);
9995       if (!lgot_ents)
9996         continue;
9997
9998       symtab_hdr = &elf_symtab_hdr (ibfd);
9999       locsymcount = symtab_hdr->sh_info;
10000       end_lgot_ents = lgot_ents + locsymcount;
10001       local_plt = (struct plt_entry **) end_lgot_ents;
10002       end_local_plt = local_plt + locsymcount;
10003       lgot_masks = (unsigned char *) end_local_plt;
10004       s = ppc64_elf_tdata (ibfd)->got;
10005       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10006         {
10007           struct got_entry **pent, *ent;
10008
10009           pent = lgot_ents;
10010           while ((ent = *pent) != NULL)
10011             if (ent->got.refcount > 0)
10012               {
10013                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10014                   {
10015                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10016                     *pent = ent->next;
10017                   }
10018                 else
10019                   {
10020                     unsigned int ent_size = 8;
10021                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10022
10023                     ent->got.offset = s->size;
10024                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10025                       {
10026                         ent_size *= 2;
10027                         rel_size *= 2;
10028                       }
10029                     s->size += ent_size;
10030                     if ((*lgot_masks & PLT_IFUNC) != 0)
10031                       {
10032                         htab->elf.irelplt->size += rel_size;
10033                         htab->got_reli_size += rel_size;
10034                       }
10035                     else if (bfd_link_pic (info)
10036                              && !((ent->tls_type & TLS_TPREL) != 0
10037                                   && bfd_link_executable (info)))
10038                       {
10039                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10040                         srel->size += rel_size;
10041                       }
10042                     pent = &ent->next;
10043                   }
10044               }
10045             else
10046               *pent = ent->next;
10047         }
10048
10049       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10050       for (; local_plt < end_local_plt; ++local_plt)
10051         {
10052           struct plt_entry *ent;
10053
10054           for (ent = *local_plt; ent != NULL; ent = ent->next)
10055             if (ent->plt.refcount > 0)
10056               {
10057                 s = htab->elf.iplt;
10058                 ent->plt.offset = s->size;
10059                 s->size += PLT_ENTRY_SIZE (htab);
10060
10061                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10062               }
10063             else
10064               ent->plt.offset = (bfd_vma) -1;
10065         }
10066     }
10067
10068   /* Allocate global sym .plt and .got entries, and space for global
10069      sym dynamic relocs.  */
10070   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10071   /* Stash the end of glink branch table.  */
10072   if (htab->glink != NULL)
10073     htab->glink->rawsize = htab->glink->size;
10074
10075   if (!htab->opd_abi && !bfd_link_pic (info))
10076     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10077
10078   first_tlsld = NULL;
10079   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10080     {
10081       struct got_entry *ent;
10082
10083       if (!is_ppc64_elf (ibfd))
10084         continue;
10085
10086       ent = ppc64_tlsld_got (ibfd);
10087       if (ent->got.refcount > 0)
10088         {
10089           if (!htab->do_multi_toc && first_tlsld != NULL)
10090             {
10091               ent->is_indirect = TRUE;
10092               ent->got.ent = first_tlsld;
10093             }
10094           else
10095             {
10096               if (first_tlsld == NULL)
10097                 first_tlsld = ent;
10098               s = ppc64_elf_tdata (ibfd)->got;
10099               ent->got.offset = s->size;
10100               ent->owner = ibfd;
10101               s->size += 16;
10102               if (bfd_link_pic (info))
10103                 {
10104                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10105                   srel->size += sizeof (Elf64_External_Rela);
10106                 }
10107             }
10108         }
10109       else
10110         ent->got.offset = (bfd_vma) -1;
10111     }
10112
10113   /* We now have determined the sizes of the various dynamic sections.
10114      Allocate memory for them.  */
10115   relocs = FALSE;
10116   for (s = dynobj->sections; s != NULL; s = s->next)
10117     {
10118       if ((s->flags & SEC_LINKER_CREATED) == 0)
10119         continue;
10120
10121       if (s == htab->brlt || s == htab->relbrlt)
10122         /* These haven't been allocated yet;  don't strip.  */
10123         continue;
10124       else if (s == htab->elf.sgot
10125                || s == htab->elf.splt
10126                || s == htab->elf.iplt
10127                || s == htab->glink
10128                || s == htab->elf.sdynbss
10129                || s == htab->elf.sdynrelro)
10130         {
10131           /* Strip this section if we don't need it; see the
10132              comment below.  */
10133         }
10134       else if (s == htab->glink_eh_frame)
10135         {
10136           if (!bfd_is_abs_section (s->output_section))
10137             /* Not sized yet.  */
10138             continue;
10139         }
10140       else if (CONST_STRNEQ (s->name, ".rela"))
10141         {
10142           if (s->size != 0)
10143             {
10144               if (s != htab->elf.srelplt)
10145                 relocs = TRUE;
10146
10147               /* We use the reloc_count field as a counter if we need
10148                  to copy relocs into the output file.  */
10149               s->reloc_count = 0;
10150             }
10151         }
10152       else
10153         {
10154           /* It's not one of our sections, so don't allocate space.  */
10155           continue;
10156         }
10157
10158       if (s->size == 0)
10159         {
10160           /* If we don't need this section, strip it from the
10161              output file.  This is mostly to handle .rela.bss and
10162              .rela.plt.  We must create both sections in
10163              create_dynamic_sections, because they must be created
10164              before the linker maps input sections to output
10165              sections.  The linker does that before
10166              adjust_dynamic_symbol is called, and it is that
10167              function which decides whether anything needs to go
10168              into these sections.  */
10169           s->flags |= SEC_EXCLUDE;
10170           continue;
10171         }
10172
10173       if (bfd_is_abs_section (s->output_section))
10174         _bfd_error_handler (_("warning: discarding dynamic section %s"),
10175                             s->name);
10176
10177       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10178         continue;
10179
10180       /* Allocate memory for the section contents.  We use bfd_zalloc
10181          here in case unused entries are not reclaimed before the
10182          section's contents are written out.  This should not happen,
10183          but this way if it does we get a R_PPC64_NONE reloc in .rela
10184          sections instead of garbage.
10185          We also rely on the section contents being zero when writing
10186          the GOT and .dynrelro.  */
10187       s->contents = bfd_zalloc (dynobj, s->size);
10188       if (s->contents == NULL)
10189         return FALSE;
10190     }
10191
10192   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10193     {
10194       if (!is_ppc64_elf (ibfd))
10195         continue;
10196
10197       s = ppc64_elf_tdata (ibfd)->got;
10198       if (s != NULL && s != htab->elf.sgot)
10199         {
10200           if (s->size == 0)
10201             s->flags |= SEC_EXCLUDE;
10202           else
10203             {
10204               s->contents = bfd_zalloc (ibfd, s->size);
10205               if (s->contents == NULL)
10206                 return FALSE;
10207             }
10208         }
10209       s = ppc64_elf_tdata (ibfd)->relgot;
10210       if (s != NULL)
10211         {
10212           if (s->size == 0)
10213             s->flags |= SEC_EXCLUDE;
10214           else
10215             {
10216               s->contents = bfd_zalloc (ibfd, s->size);
10217               if (s->contents == NULL)
10218                 return FALSE;
10219               relocs = TRUE;
10220               s->reloc_count = 0;
10221             }
10222         }
10223     }
10224
10225   if (htab->elf.dynamic_sections_created)
10226     {
10227       bfd_boolean tls_opt;
10228
10229       /* Add some entries to the .dynamic section.  We fill in the
10230          values later, in ppc64_elf_finish_dynamic_sections, but we
10231          must add the entries now so that we get the correct size for
10232          the .dynamic section.  The DT_DEBUG entry is filled in by the
10233          dynamic linker and used by the debugger.  */
10234 #define add_dynamic_entry(TAG, VAL) \
10235   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10236
10237       if (bfd_link_executable (info))
10238         {
10239           if (!add_dynamic_entry (DT_DEBUG, 0))
10240             return FALSE;
10241         }
10242
10243       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10244         {
10245           if (!add_dynamic_entry (DT_PLTGOT, 0)
10246               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10247               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10248               || !add_dynamic_entry (DT_JMPREL, 0)
10249               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10250             return FALSE;
10251         }
10252
10253       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10254         {
10255           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10256               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10257             return FALSE;
10258         }
10259
10260       tls_opt = (htab->params->tls_get_addr_opt
10261                  && htab->tls_get_addr_fd != NULL
10262                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10263       if (tls_opt || !htab->opd_abi)
10264         {
10265           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10266             return FALSE;
10267         }
10268
10269       if (relocs)
10270         {
10271           if (!add_dynamic_entry (DT_RELA, 0)
10272               || !add_dynamic_entry (DT_RELASZ, 0)
10273               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10274             return FALSE;
10275
10276           /* If any dynamic relocs apply to a read-only section,
10277              then we need a DT_TEXTREL entry.  */
10278           if ((info->flags & DF_TEXTREL) == 0)
10279             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10280
10281           if ((info->flags & DF_TEXTREL) != 0)
10282             {
10283               if (!add_dynamic_entry (DT_TEXTREL, 0))
10284                 return FALSE;
10285             }
10286         }
10287     }
10288 #undef add_dynamic_entry
10289
10290   return TRUE;
10291 }
10292
10293 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10294
10295 static bfd_boolean
10296 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10297 {
10298   if (h->plt.plist != NULL
10299       && !h->def_regular
10300       && !h->pointer_equality_needed)
10301     return FALSE;
10302
10303   return _bfd_elf_hash_symbol (h);
10304 }
10305
10306 /* Determine the type of stub needed, if any, for a call.  */
10307
10308 static inline enum ppc_stub_type
10309 ppc_type_of_stub (asection *input_sec,
10310                   const Elf_Internal_Rela *rel,
10311                   struct ppc_link_hash_entry **hash,
10312                   struct plt_entry **plt_ent,
10313                   bfd_vma destination,
10314                   unsigned long local_off)
10315 {
10316   struct ppc_link_hash_entry *h = *hash;
10317   bfd_vma location;
10318   bfd_vma branch_offset;
10319   bfd_vma max_branch_offset;
10320   enum elf_ppc64_reloc_type r_type;
10321
10322   if (h != NULL)
10323     {
10324       struct plt_entry *ent;
10325       struct ppc_link_hash_entry *fdh = h;
10326       if (h->oh != NULL
10327           && h->oh->is_func_descriptor)
10328         {
10329           fdh = ppc_follow_link (h->oh);
10330           *hash = fdh;
10331         }
10332
10333       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10334         if (ent->addend == rel->r_addend
10335             && ent->plt.offset != (bfd_vma) -1)
10336           {
10337             *plt_ent = ent;
10338             return ppc_stub_plt_call;
10339           }
10340
10341       /* Here, we know we don't have a plt entry.  If we don't have a
10342          either a defined function descriptor or a defined entry symbol
10343          in a regular object file, then it is pointless trying to make
10344          any other type of stub.  */
10345       if (!is_static_defined (&fdh->elf)
10346           && !is_static_defined (&h->elf))
10347         return ppc_stub_none;
10348     }
10349   else if (elf_local_got_ents (input_sec->owner) != NULL)
10350     {
10351       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10352       struct plt_entry **local_plt = (struct plt_entry **)
10353         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10354       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10355
10356       if (local_plt[r_symndx] != NULL)
10357         {
10358           struct plt_entry *ent;
10359
10360           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10361             if (ent->addend == rel->r_addend
10362                 && ent->plt.offset != (bfd_vma) -1)
10363               {
10364                 *plt_ent = ent;
10365                 return ppc_stub_plt_call;
10366               }
10367         }
10368     }
10369
10370   /* Determine where the call point is.  */
10371   location = (input_sec->output_offset
10372               + input_sec->output_section->vma
10373               + rel->r_offset);
10374
10375   branch_offset = destination - location;
10376   r_type = ELF64_R_TYPE (rel->r_info);
10377
10378   /* Determine if a long branch stub is needed.  */
10379   max_branch_offset = 1 << 25;
10380   if (r_type != R_PPC64_REL24)
10381     max_branch_offset = 1 << 15;
10382
10383   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10384     /* We need a stub.  Figure out whether a long_branch or plt_branch
10385        is needed later.  */
10386     return ppc_stub_long_branch;
10387
10388   return ppc_stub_none;
10389 }
10390
10391 /* With power7 weakly ordered memory model, it is possible for ld.so
10392    to update a plt entry in one thread and have another thread see a
10393    stale zero toc entry.  To avoid this we need some sort of acquire
10394    barrier in the call stub.  One solution is to make the load of the
10395    toc word seem to appear to depend on the load of the function entry
10396    word.  Another solution is to test for r2 being zero, and branch to
10397    the appropriate glink entry if so.
10398
10399    .    fake dep barrier        compare
10400    .    ld 12,xxx(2)            ld 12,xxx(2)
10401    .    mtctr 12                mtctr 12
10402    .    xor 11,12,12            ld 2,xxx+8(2)
10403    .    add 2,2,11              cmpldi 2,0
10404    .    ld 2,xxx+8(2)           bnectr+
10405    .    bctr                    b <glink_entry>
10406
10407    The solution involving the compare turns out to be faster, so
10408    that's what we use unless the branch won't reach.  */
10409
10410 #define ALWAYS_USE_FAKE_DEP 0
10411 #define ALWAYS_EMIT_R2SAVE 0
10412
10413 #define PPC_LO(v) ((v) & 0xffff)
10414 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10415 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10416
10417 static inline unsigned int
10418 plt_stub_size (struct ppc_link_hash_table *htab,
10419                struct ppc_stub_hash_entry *stub_entry,
10420                bfd_vma off)
10421 {
10422   unsigned size = 12;
10423
10424   if (ALWAYS_EMIT_R2SAVE
10425       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10426     size += 4;
10427   if (PPC_HA (off) != 0)
10428     size += 4;
10429   if (htab->opd_abi)
10430     {
10431       size += 4;
10432       if (htab->params->plt_static_chain)
10433         size += 4;
10434       if (htab->params->plt_thread_safe
10435           && htab->elf.dynamic_sections_created
10436           && stub_entry->h != NULL
10437           && stub_entry->h->elf.dynindx != -1)
10438         size += 8;
10439       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10440         size += 4;
10441     }
10442   if (stub_entry->h != NULL
10443       && (stub_entry->h == htab->tls_get_addr_fd
10444           || stub_entry->h == htab->tls_get_addr)
10445       && htab->params->tls_get_addr_opt)
10446     {
10447       size += 7 * 4;
10448       if (ALWAYS_EMIT_R2SAVE
10449           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10450         size += 6 * 4;
10451     }
10452   return size;
10453 }
10454
10455 /* Depending on the sign of plt_stub_align:
10456    If positive, return the padding to align to a 2**plt_stub_align
10457    boundary.
10458    If negative, if this stub would cross fewer 2**plt_stub_align
10459    boundaries if we align, then return the padding needed to do so.  */
10460
10461 static inline unsigned int
10462 plt_stub_pad (struct ppc_link_hash_table *htab,
10463               struct ppc_stub_hash_entry *stub_entry,
10464               bfd_vma plt_off)
10465 {
10466   int stub_align;
10467   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10468   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10469
10470   if (htab->params->plt_stub_align >= 0)
10471     {
10472       stub_align = 1 << htab->params->plt_stub_align;
10473       if ((stub_off & (stub_align - 1)) != 0)
10474         return stub_align - (stub_off & (stub_align - 1));
10475       return 0;
10476     }
10477
10478   stub_align = 1 << -htab->params->plt_stub_align;
10479   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10480       > ((stub_size - 1) & -stub_align))
10481     return stub_align - (stub_off & (stub_align - 1));
10482   return 0;
10483 }
10484
10485 /* Build a .plt call stub.  */
10486
10487 static inline bfd_byte *
10488 build_plt_stub (struct ppc_link_hash_table *htab,
10489                 struct ppc_stub_hash_entry *stub_entry,
10490                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10491 {
10492   bfd *obfd = htab->params->stub_bfd;
10493   bfd_boolean plt_load_toc = htab->opd_abi;
10494   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10495   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10496                                  && htab->elf.dynamic_sections_created
10497                                  && stub_entry->h != NULL
10498                                  && stub_entry->h->elf.dynindx != -1);
10499   bfd_boolean use_fake_dep = plt_thread_safe;
10500   bfd_vma cmp_branch_off = 0;
10501
10502   if (!ALWAYS_USE_FAKE_DEP
10503       && plt_load_toc
10504       && plt_thread_safe
10505       && !((stub_entry->h == htab->tls_get_addr_fd
10506             || stub_entry->h == htab->tls_get_addr)
10507            && htab->params->tls_get_addr_opt))
10508     {
10509       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10510       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10511                           / PLT_ENTRY_SIZE (htab));
10512       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10513       bfd_vma to, from;
10514
10515       if (pltindex > 32768)
10516         glinkoff += (pltindex - 32768) * 4;
10517       to = (glinkoff
10518             + htab->glink->output_offset
10519             + htab->glink->output_section->vma);
10520       from = (p - stub_entry->group->stub_sec->contents
10521               + 4 * (ALWAYS_EMIT_R2SAVE
10522                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10523               + 4 * (PPC_HA (offset) != 0)
10524               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10525                      != PPC_HA (offset))
10526               + 4 * (plt_static_chain != 0)
10527               + 20
10528               + stub_entry->group->stub_sec->output_offset
10529               + stub_entry->group->stub_sec->output_section->vma);
10530       cmp_branch_off = to - from;
10531       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10532     }
10533
10534   if (PPC_HA (offset) != 0)
10535     {
10536       if (r != NULL)
10537         {
10538           if (ALWAYS_EMIT_R2SAVE
10539               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10540             r[0].r_offset += 4;
10541           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10542           r[1].r_offset = r[0].r_offset + 4;
10543           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10544           r[1].r_addend = r[0].r_addend;
10545           if (plt_load_toc)
10546             {
10547               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10548                 {
10549                   r[2].r_offset = r[1].r_offset + 4;
10550                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10551                   r[2].r_addend = r[0].r_addend;
10552                 }
10553               else
10554                 {
10555                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10556                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10557                   r[2].r_addend = r[0].r_addend + 8;
10558                   if (plt_static_chain)
10559                     {
10560                       r[3].r_offset = r[2].r_offset + 4;
10561                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10562                       r[3].r_addend = r[0].r_addend + 16;
10563                     }
10564                 }
10565             }
10566         }
10567       if (ALWAYS_EMIT_R2SAVE
10568           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10569         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10570       if (plt_load_toc)
10571         {
10572           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10573           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10574         }
10575       else
10576         {
10577           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10578           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10579         }
10580       if (plt_load_toc
10581           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10582         {
10583           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10584           offset = 0;
10585         }
10586       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10587       if (plt_load_toc)
10588         {
10589           if (use_fake_dep)
10590             {
10591               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10592               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10593             }
10594           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10595           if (plt_static_chain)
10596             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10597         }
10598     }
10599   else
10600     {
10601       if (r != NULL)
10602         {
10603           if (ALWAYS_EMIT_R2SAVE
10604               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10605             r[0].r_offset += 4;
10606           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10607           if (plt_load_toc)
10608             {
10609               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10610                 {
10611                   r[1].r_offset = r[0].r_offset + 4;
10612                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10613                   r[1].r_addend = r[0].r_addend;
10614                 }
10615               else
10616                 {
10617                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10618                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10619                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10620                   if (plt_static_chain)
10621                     {
10622                       r[2].r_offset = r[1].r_offset + 4;
10623                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10624                       r[2].r_addend = r[0].r_addend + 8;
10625                     }
10626                 }
10627             }
10628         }
10629       if (ALWAYS_EMIT_R2SAVE
10630           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10631         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10632       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10633       if (plt_load_toc
10634           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10635         {
10636           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10637           offset = 0;
10638         }
10639       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10640       if (plt_load_toc)
10641         {
10642           if (use_fake_dep)
10643             {
10644               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10645               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10646             }
10647           if (plt_static_chain)
10648             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10649           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10650         }
10651     }
10652   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10653     {
10654       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10655       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10656       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10657     }
10658   else
10659     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10660   return p;
10661 }
10662
10663 /* Build a special .plt call stub for __tls_get_addr.  */
10664
10665 #define LD_R11_0R3      0xe9630000
10666 #define LD_R12_0R3      0xe9830000
10667 #define MR_R0_R3        0x7c601b78
10668 #define CMPDI_R11_0     0x2c2b0000
10669 #define ADD_R3_R12_R13  0x7c6c6a14
10670 #define BEQLR           0x4d820020
10671 #define MR_R3_R0        0x7c030378
10672 #define STD_R11_0R1     0xf9610000
10673 #define BCTRL           0x4e800421
10674 #define LD_R11_0R1      0xe9610000
10675 #define MTLR_R11        0x7d6803a6
10676
10677 static inline bfd_byte *
10678 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10679                          struct ppc_stub_hash_entry *stub_entry,
10680                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10681 {
10682   bfd *obfd = htab->params->stub_bfd;
10683
10684   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10685   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10686   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10687   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10688   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10689   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10690   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10691   if (r != NULL)
10692     r[0].r_offset += 7 * 4;
10693   if (!ALWAYS_EMIT_R2SAVE
10694       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10695     return build_plt_stub (htab, stub_entry, p, offset, r);
10696
10697   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10698   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10699
10700   if (r != NULL)
10701     r[0].r_offset += 2 * 4;
10702   p = build_plt_stub (htab, stub_entry, p, offset, r);
10703   bfd_put_32 (obfd, BCTRL, p - 4);
10704
10705   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10706   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10707   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10708   bfd_put_32 (obfd, BLR, p),                    p += 4;
10709
10710   return p;
10711 }
10712
10713 static Elf_Internal_Rela *
10714 get_relocs (asection *sec, int count)
10715 {
10716   Elf_Internal_Rela *relocs;
10717   struct bfd_elf_section_data *elfsec_data;
10718
10719   elfsec_data = elf_section_data (sec);
10720   relocs = elfsec_data->relocs;
10721   if (relocs == NULL)
10722     {
10723       bfd_size_type relsize;
10724       relsize = sec->reloc_count * sizeof (*relocs);
10725       relocs = bfd_alloc (sec->owner, relsize);
10726       if (relocs == NULL)
10727         return NULL;
10728       elfsec_data->relocs = relocs;
10729       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10730                                           sizeof (Elf_Internal_Shdr));
10731       if (elfsec_data->rela.hdr == NULL)
10732         return NULL;
10733       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10734                                         * sizeof (Elf64_External_Rela));
10735       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10736       sec->reloc_count = 0;
10737     }
10738   relocs += sec->reloc_count;
10739   sec->reloc_count += count;
10740   return relocs;
10741 }
10742
10743 static bfd_vma
10744 get_r2off (struct bfd_link_info *info,
10745            struct ppc_stub_hash_entry *stub_entry)
10746 {
10747   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10748   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10749
10750   if (r2off == 0)
10751     {
10752       /* Support linking -R objects.  Get the toc pointer from the
10753          opd entry.  */
10754       char buf[8];
10755       if (!htab->opd_abi)
10756         return r2off;
10757       asection *opd = stub_entry->h->elf.root.u.def.section;
10758       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10759
10760       if (strcmp (opd->name, ".opd") != 0
10761           || opd->reloc_count != 0)
10762         {
10763           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10764                                   stub_entry->h->elf.root.root.string);
10765           bfd_set_error (bfd_error_bad_value);
10766           return (bfd_vma) -1;
10767         }
10768       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10769         return (bfd_vma) -1;
10770       r2off = bfd_get_64 (opd->owner, buf);
10771       r2off -= elf_gp (info->output_bfd);
10772     }
10773   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10774   return r2off;
10775 }
10776
10777 static bfd_boolean
10778 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10779 {
10780   struct ppc_stub_hash_entry *stub_entry;
10781   struct ppc_branch_hash_entry *br_entry;
10782   struct bfd_link_info *info;
10783   struct ppc_link_hash_table *htab;
10784   bfd_byte *loc;
10785   bfd_byte *p;
10786   bfd_vma dest, off;
10787   int size;
10788   Elf_Internal_Rela *r;
10789   asection *plt;
10790
10791   /* Massage our args to the form they really have.  */
10792   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10793   info = in_arg;
10794
10795   htab = ppc_hash_table (info);
10796   if (htab == NULL)
10797     return FALSE;
10798
10799   /* Make a note of the offset within the stubs for this entry.  */
10800   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10801   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10802
10803   htab->stub_count[stub_entry->stub_type - 1] += 1;
10804   switch (stub_entry->stub_type)
10805     {
10806     case ppc_stub_long_branch:
10807     case ppc_stub_long_branch_r2off:
10808       /* Branches are relative.  This is where we are going to.  */
10809       dest = (stub_entry->target_value
10810               + stub_entry->target_section->output_offset
10811               + stub_entry->target_section->output_section->vma);
10812       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10813       off = dest;
10814
10815       /* And this is where we are coming from.  */
10816       off -= (stub_entry->stub_offset
10817               + stub_entry->group->stub_sec->output_offset
10818               + stub_entry->group->stub_sec->output_section->vma);
10819
10820       size = 4;
10821       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10822         {
10823           bfd_vma r2off = get_r2off (info, stub_entry);
10824
10825           if (r2off == (bfd_vma) -1)
10826             {
10827               htab->stub_error = TRUE;
10828               return FALSE;
10829             }
10830           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10831           loc += 4;
10832           size = 8;
10833           if (PPC_HA (r2off) != 0)
10834             {
10835               bfd_put_32 (htab->params->stub_bfd,
10836                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10837               loc += 4;
10838               size += 4;
10839             }
10840           if (PPC_LO (r2off) != 0)
10841             {
10842               bfd_put_32 (htab->params->stub_bfd,
10843                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10844               loc += 4;
10845               size += 4;
10846             }
10847           off -= size - 4;
10848         }
10849       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10850
10851       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10852         {
10853           info->callbacks->einfo
10854             (_("%P: long branch stub `%s' offset overflow\n"),
10855              stub_entry->root.string);
10856           htab->stub_error = TRUE;
10857           return FALSE;
10858         }
10859
10860       if (info->emitrelocations)
10861         {
10862           r = get_relocs (stub_entry->group->stub_sec, 1);
10863           if (r == NULL)
10864             return FALSE;
10865           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10866           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10867           r->r_addend = dest;
10868           if (stub_entry->h != NULL)
10869             {
10870               struct elf_link_hash_entry **hashes;
10871               unsigned long symndx;
10872               struct ppc_link_hash_entry *h;
10873
10874               hashes = elf_sym_hashes (htab->params->stub_bfd);
10875               if (hashes == NULL)
10876                 {
10877                   bfd_size_type hsize;
10878
10879                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10880                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10881                   if (hashes == NULL)
10882                     return FALSE;
10883                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10884                   htab->stub_globals = 1;
10885                 }
10886               symndx = htab->stub_globals++;
10887               h = stub_entry->h;
10888               hashes[symndx] = &h->elf;
10889               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10890               if (h->oh != NULL && h->oh->is_func)
10891                 h = ppc_follow_link (h->oh);
10892               if (h->elf.root.u.def.section != stub_entry->target_section)
10893                 /* H is an opd symbol.  The addend must be zero.  */
10894                 r->r_addend = 0;
10895               else
10896                 {
10897                   off = (h->elf.root.u.def.value
10898                          + h->elf.root.u.def.section->output_offset
10899                          + h->elf.root.u.def.section->output_section->vma);
10900                   r->r_addend -= off;
10901                 }
10902             }
10903         }
10904       break;
10905
10906     case ppc_stub_plt_branch:
10907     case ppc_stub_plt_branch_r2off:
10908       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10909                                          stub_entry->root.string + 9,
10910                                          FALSE, FALSE);
10911       if (br_entry == NULL)
10912         {
10913           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10914                                   stub_entry->root.string);
10915           htab->stub_error = TRUE;
10916           return FALSE;
10917         }
10918
10919       dest = (stub_entry->target_value
10920               + stub_entry->target_section->output_offset
10921               + stub_entry->target_section->output_section->vma);
10922       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10923         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10924
10925       bfd_put_64 (htab->brlt->owner, dest,
10926                   htab->brlt->contents + br_entry->offset);
10927
10928       if (br_entry->iter == htab->stub_iteration)
10929         {
10930           br_entry->iter = 0;
10931
10932           if (htab->relbrlt != NULL)
10933             {
10934               /* Create a reloc for the branch lookup table entry.  */
10935               Elf_Internal_Rela rela;
10936               bfd_byte *rl;
10937
10938               rela.r_offset = (br_entry->offset
10939                                + htab->brlt->output_offset
10940                                + htab->brlt->output_section->vma);
10941               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10942               rela.r_addend = dest;
10943
10944               rl = htab->relbrlt->contents;
10945               rl += (htab->relbrlt->reloc_count++
10946                      * sizeof (Elf64_External_Rela));
10947               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10948             }
10949           else if (info->emitrelocations)
10950             {
10951               r = get_relocs (htab->brlt, 1);
10952               if (r == NULL)
10953                 return FALSE;
10954               /* brlt, being SEC_LINKER_CREATED does not go through the
10955                  normal reloc processing.  Symbols and offsets are not
10956                  translated from input file to output file form, so
10957                  set up the offset per the output file.  */
10958               r->r_offset = (br_entry->offset
10959                              + htab->brlt->output_offset
10960                              + htab->brlt->output_section->vma);
10961               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10962               r->r_addend = dest;
10963             }
10964         }
10965
10966       dest = (br_entry->offset
10967               + htab->brlt->output_offset
10968               + htab->brlt->output_section->vma);
10969
10970       off = (dest
10971              - elf_gp (info->output_bfd)
10972              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10973
10974       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10975         {
10976           info->callbacks->einfo
10977             (_("%P: linkage table error against `%T'\n"),
10978              stub_entry->root.string);
10979           bfd_set_error (bfd_error_bad_value);
10980           htab->stub_error = TRUE;
10981           return FALSE;
10982         }
10983
10984       if (info->emitrelocations)
10985         {
10986           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10987           if (r == NULL)
10988             return FALSE;
10989           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10990           if (bfd_big_endian (info->output_bfd))
10991             r[0].r_offset += 2;
10992           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10993             r[0].r_offset += 4;
10994           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10995           r[0].r_addend = dest;
10996           if (PPC_HA (off) != 0)
10997             {
10998               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10999               r[1].r_offset = r[0].r_offset + 4;
11000               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11001               r[1].r_addend = r[0].r_addend;
11002             }
11003         }
11004
11005       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11006         {
11007           if (PPC_HA (off) != 0)
11008             {
11009               size = 16;
11010               bfd_put_32 (htab->params->stub_bfd,
11011                           ADDIS_R12_R2 | PPC_HA (off), loc);
11012               loc += 4;
11013               bfd_put_32 (htab->params->stub_bfd,
11014                           LD_R12_0R12 | PPC_LO (off), loc);
11015             }
11016           else
11017             {
11018               size = 12;
11019               bfd_put_32 (htab->params->stub_bfd,
11020                           LD_R12_0R2 | PPC_LO (off), loc);
11021             }
11022         }
11023       else
11024         {
11025           bfd_vma r2off = get_r2off (info, stub_entry);
11026
11027           if (r2off == (bfd_vma) -1)
11028             {
11029               htab->stub_error = TRUE;
11030               return FALSE;
11031             }
11032
11033           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11034           loc += 4;
11035           size = 16;
11036           if (PPC_HA (off) != 0)
11037             {
11038               size += 4;
11039               bfd_put_32 (htab->params->stub_bfd,
11040                           ADDIS_R12_R2 | PPC_HA (off), loc);
11041               loc += 4;
11042               bfd_put_32 (htab->params->stub_bfd,
11043                           LD_R12_0R12 | PPC_LO (off), loc);
11044             }
11045           else
11046             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11047
11048           if (PPC_HA (r2off) != 0)
11049             {
11050               size += 4;
11051               loc += 4;
11052               bfd_put_32 (htab->params->stub_bfd,
11053                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11054             }
11055           if (PPC_LO (r2off) != 0)
11056             {
11057               size += 4;
11058               loc += 4;
11059               bfd_put_32 (htab->params->stub_bfd,
11060                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11061             }
11062         }
11063       loc += 4;
11064       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11065       loc += 4;
11066       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11067       break;
11068
11069     case ppc_stub_plt_call:
11070     case ppc_stub_plt_call_r2save:
11071       if (stub_entry->h != NULL
11072           && stub_entry->h->is_func_descriptor
11073           && stub_entry->h->oh != NULL)
11074         {
11075           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11076
11077           /* If the old-ABI "dot-symbol" is undefined make it weak so
11078              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11079           if (fh->elf.root.type == bfd_link_hash_undefined
11080               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11081                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11082             fh->elf.root.type = bfd_link_hash_undefweak;
11083         }
11084
11085       /* Now build the stub.  */
11086       dest = stub_entry->plt_ent->plt.offset & ~1;
11087       if (dest >= (bfd_vma) -2)
11088         abort ();
11089
11090       plt = htab->elf.splt;
11091       if (!htab->elf.dynamic_sections_created
11092           || stub_entry->h == NULL
11093           || stub_entry->h->elf.dynindx == -1)
11094         plt = htab->elf.iplt;
11095
11096       dest += plt->output_offset + plt->output_section->vma;
11097
11098       if (stub_entry->h == NULL
11099           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11100         {
11101           Elf_Internal_Rela rela;
11102           bfd_byte *rl;
11103
11104           rela.r_offset = dest;
11105           if (htab->opd_abi)
11106             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11107           else
11108             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11109           rela.r_addend = (stub_entry->target_value
11110                            + stub_entry->target_section->output_offset
11111                            + stub_entry->target_section->output_section->vma);
11112
11113           rl = (htab->elf.irelplt->contents
11114                 + (htab->elf.irelplt->reloc_count++
11115                    * sizeof (Elf64_External_Rela)));
11116           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11117           stub_entry->plt_ent->plt.offset |= 1;
11118           htab->local_ifunc_resolver = 1;
11119         }
11120
11121       off = (dest
11122              - elf_gp (info->output_bfd)
11123              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11124
11125       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11126         {
11127           info->callbacks->einfo
11128             /* xgettext:c-format */
11129             (_("%P: linkage table error against `%T'\n"),
11130              stub_entry->h != NULL
11131              ? stub_entry->h->elf.root.root.string
11132              : "<local sym>");
11133           bfd_set_error (bfd_error_bad_value);
11134           htab->stub_error = TRUE;
11135           return FALSE;
11136         }
11137
11138       if (htab->params->plt_stub_align != 0)
11139         {
11140           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11141
11142           stub_entry->group->stub_sec->size += pad;
11143           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11144           loc += pad;
11145         }
11146
11147       r = NULL;
11148       if (info->emitrelocations)
11149         {
11150           r = get_relocs (stub_entry->group->stub_sec,
11151                           ((PPC_HA (off) != 0)
11152                            + (htab->opd_abi
11153                               ? 2 + (htab->params->plt_static_chain
11154                                      && PPC_HA (off + 16) == PPC_HA (off))
11155                               : 1)));
11156           if (r == NULL)
11157             return FALSE;
11158           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11159           if (bfd_big_endian (info->output_bfd))
11160             r[0].r_offset += 2;
11161           r[0].r_addend = dest;
11162         }
11163       if (stub_entry->h != NULL
11164           && (stub_entry->h == htab->tls_get_addr_fd
11165               || stub_entry->h == htab->tls_get_addr)
11166           && htab->params->tls_get_addr_opt)
11167         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11168       else
11169         p = build_plt_stub (htab, stub_entry, loc, off, r);
11170       size = p - loc;
11171       break;
11172
11173     case ppc_stub_save_res:
11174       return TRUE;
11175
11176     default:
11177       BFD_FAIL ();
11178       return FALSE;
11179     }
11180
11181   stub_entry->group->stub_sec->size += size;
11182
11183   if (htab->params->emit_stub_syms)
11184     {
11185       struct elf_link_hash_entry *h;
11186       size_t len1, len2;
11187       char *name;
11188       const char *const stub_str[] = { "long_branch",
11189                                        "long_branch_r2off",
11190                                        "plt_branch",
11191                                        "plt_branch_r2off",
11192                                        "plt_call",
11193                                        "plt_call" };
11194
11195       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11196       len2 = strlen (stub_entry->root.string);
11197       name = bfd_malloc (len1 + len2 + 2);
11198       if (name == NULL)
11199         return FALSE;
11200       memcpy (name, stub_entry->root.string, 9);
11201       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11202       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11203       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11204       if (h == NULL)
11205         return FALSE;
11206       if (h->root.type == bfd_link_hash_new)
11207         {
11208           h->root.type = bfd_link_hash_defined;
11209           h->root.u.def.section = stub_entry->group->stub_sec;
11210           h->root.u.def.value = stub_entry->stub_offset;
11211           h->ref_regular = 1;
11212           h->def_regular = 1;
11213           h->ref_regular_nonweak = 1;
11214           h->forced_local = 1;
11215           h->non_elf = 0;
11216           h->root.linker_def = 1;
11217         }
11218     }
11219
11220   return TRUE;
11221 }
11222
11223 /* As above, but don't actually build the stub.  Just bump offset so
11224    we know stub section sizes, and select plt_branch stubs where
11225    long_branch stubs won't do.  */
11226
11227 static bfd_boolean
11228 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11229 {
11230   struct ppc_stub_hash_entry *stub_entry;
11231   struct bfd_link_info *info;
11232   struct ppc_link_hash_table *htab;
11233   bfd_vma off;
11234   int size;
11235
11236   /* Massage our args to the form they really have.  */
11237   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11238   info = in_arg;
11239
11240   htab = ppc_hash_table (info);
11241   if (htab == NULL)
11242     return FALSE;
11243
11244   if (stub_entry->h != NULL
11245       && stub_entry->h->save_res
11246       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11247       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11248     {
11249       /* Don't make stubs to out-of-line register save/restore
11250          functions.  Instead, emit copies of the functions.  */
11251       stub_entry->group->needs_save_res = 1;
11252       stub_entry->stub_type = ppc_stub_save_res;
11253       return TRUE;
11254     }
11255
11256   if (stub_entry->stub_type == ppc_stub_plt_call
11257       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11258     {
11259       asection *plt;
11260       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11261       if (off >= (bfd_vma) -2)
11262         abort ();
11263       plt = htab->elf.splt;
11264       if (!htab->elf.dynamic_sections_created
11265           || stub_entry->h == NULL
11266           || stub_entry->h->elf.dynindx == -1)
11267         plt = htab->elf.iplt;
11268       off += (plt->output_offset
11269               + plt->output_section->vma
11270               - elf_gp (info->output_bfd)
11271               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11272
11273       size = plt_stub_size (htab, stub_entry, off);
11274       if (stub_entry->h != NULL
11275           && (stub_entry->h == htab->tls_get_addr_fd
11276               || stub_entry->h == htab->tls_get_addr)
11277           && htab->params->tls_get_addr_opt
11278           && (ALWAYS_EMIT_R2SAVE
11279               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11280         stub_entry->group->tls_get_addr_opt_bctrl
11281           = stub_entry->group->stub_sec->size + size - 5 * 4;
11282
11283       if (htab->params->plt_stub_align)
11284         size += plt_stub_pad (htab, stub_entry, off);
11285       if (info->emitrelocations)
11286         {
11287           stub_entry->group->stub_sec->reloc_count
11288             += ((PPC_HA (off) != 0)
11289                 + (htab->opd_abi
11290                    ? 2 + (htab->params->plt_static_chain
11291                           && PPC_HA (off + 16) == PPC_HA (off))
11292                    : 1));
11293           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11294         }
11295     }
11296   else
11297     {
11298       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11299          variants.  */
11300       bfd_vma r2off = 0;
11301       bfd_vma local_off = 0;
11302
11303       off = (stub_entry->target_value
11304              + stub_entry->target_section->output_offset
11305              + stub_entry->target_section->output_section->vma);
11306       off -= (stub_entry->group->stub_sec->size
11307               + stub_entry->group->stub_sec->output_offset
11308               + stub_entry->group->stub_sec->output_section->vma);
11309
11310       /* Reset the stub type from the plt variant in case we now
11311          can reach with a shorter stub.  */
11312       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11313         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11314
11315       size = 4;
11316       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11317         {
11318           r2off = get_r2off (info, stub_entry);
11319           if (r2off == (bfd_vma) -1)
11320             {
11321               htab->stub_error = TRUE;
11322               return FALSE;
11323             }
11324           size = 8;
11325           if (PPC_HA (r2off) != 0)
11326             size += 4;
11327           if (PPC_LO (r2off) != 0)
11328             size += 4;
11329           off -= size - 4;
11330         }
11331
11332       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11333
11334       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11335          Do the same for -R objects without function descriptors.  */
11336       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11337           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11338               && r2off == 0
11339               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11340         {
11341           struct ppc_branch_hash_entry *br_entry;
11342
11343           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11344                                              stub_entry->root.string + 9,
11345                                              TRUE, FALSE);
11346           if (br_entry == NULL)
11347             {
11348               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11349                                       stub_entry->root.string);
11350               htab->stub_error = TRUE;
11351               return FALSE;
11352             }
11353
11354           if (br_entry->iter != htab->stub_iteration)
11355             {
11356               br_entry->iter = htab->stub_iteration;
11357               br_entry->offset = htab->brlt->size;
11358               htab->brlt->size += 8;
11359
11360               if (htab->relbrlt != NULL)
11361                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11362               else if (info->emitrelocations)
11363                 {
11364                   htab->brlt->reloc_count += 1;
11365                   htab->brlt->flags |= SEC_RELOC;
11366                 }
11367             }
11368
11369           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11370           off = (br_entry->offset
11371                  + htab->brlt->output_offset
11372                  + htab->brlt->output_section->vma
11373                  - elf_gp (info->output_bfd)
11374                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11375
11376           if (info->emitrelocations)
11377             {
11378               stub_entry->group->stub_sec->reloc_count
11379                 += 1 + (PPC_HA (off) != 0);
11380               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11381             }
11382
11383           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11384             {
11385               size = 12;
11386               if (PPC_HA (off) != 0)
11387                 size = 16;
11388             }
11389           else
11390             {
11391               size = 16;
11392               if (PPC_HA (off) != 0)
11393                 size += 4;
11394
11395               if (PPC_HA (r2off) != 0)
11396                 size += 4;
11397               if (PPC_LO (r2off) != 0)
11398                 size += 4;
11399             }
11400         }
11401       else if (info->emitrelocations)
11402         {
11403           stub_entry->group->stub_sec->reloc_count += 1;
11404           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11405         }
11406     }
11407
11408   stub_entry->group->stub_sec->size += size;
11409   return TRUE;
11410 }
11411
11412 /* Set up various things so that we can make a list of input sections
11413    for each output section included in the link.  Returns -1 on error,
11414    0 when no stubs will be needed, and 1 on success.  */
11415
11416 int
11417 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11418 {
11419   unsigned int id;
11420   bfd_size_type amt;
11421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11422
11423   if (htab == NULL)
11424     return -1;
11425
11426   htab->sec_info_arr_size = bfd_get_next_section_id ();
11427   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11428   htab->sec_info = bfd_zmalloc (amt);
11429   if (htab->sec_info == NULL)
11430     return -1;
11431
11432   /* Set toc_off for com, und, abs and ind sections.  */
11433   for (id = 0; id < 3; id++)
11434     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11435
11436   return 1;
11437 }
11438
11439 /* Set up for first pass at multitoc partitioning.  */
11440
11441 void
11442 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11443 {
11444   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11445
11446   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11447   htab->toc_bfd = NULL;
11448   htab->toc_first_sec = NULL;
11449 }
11450
11451 /* The linker repeatedly calls this function for each TOC input section
11452    and linker generated GOT section.  Group input bfds such that the toc
11453    within a group is less than 64k in size.  */
11454
11455 bfd_boolean
11456 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11457 {
11458   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11459   bfd_vma addr, off, limit;
11460
11461   if (htab == NULL)
11462     return FALSE;
11463
11464   if (!htab->second_toc_pass)
11465     {
11466       /* Keep track of the first .toc or .got section for this input bfd.  */
11467       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11468
11469       if (new_bfd)
11470         {
11471           htab->toc_bfd = isec->owner;
11472           htab->toc_first_sec = isec;
11473         }
11474
11475       addr = isec->output_offset + isec->output_section->vma;
11476       off = addr - htab->toc_curr;
11477       limit = 0x80008000;
11478       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11479         limit = 0x10000;
11480       if (off + isec->size > limit)
11481         {
11482           addr = (htab->toc_first_sec->output_offset
11483                   + htab->toc_first_sec->output_section->vma);
11484           htab->toc_curr = addr;
11485           htab->toc_curr &= -TOC_BASE_ALIGN;
11486         }
11487
11488       /* toc_curr is the base address of this toc group.  Set elf_gp
11489          for the input section to be the offset relative to the
11490          output toc base plus 0x8000.  Making the input elf_gp an
11491          offset allows us to move the toc as a whole without
11492          recalculating input elf_gp.  */
11493       off = htab->toc_curr - elf_gp (info->output_bfd);
11494       off += TOC_BASE_OFF;
11495
11496       /* Die if someone uses a linker script that doesn't keep input
11497          file .toc and .got together.  */
11498       if (new_bfd
11499           && elf_gp (isec->owner) != 0
11500           && elf_gp (isec->owner) != off)
11501         return FALSE;
11502
11503       elf_gp (isec->owner) = off;
11504       return TRUE;
11505     }
11506
11507   /* During the second pass toc_first_sec points to the start of
11508      a toc group, and toc_curr is used to track the old elf_gp.
11509      We use toc_bfd to ensure we only look at each bfd once.  */
11510   if (htab->toc_bfd == isec->owner)
11511     return TRUE;
11512   htab->toc_bfd = isec->owner;
11513
11514   if (htab->toc_first_sec == NULL
11515       || htab->toc_curr != elf_gp (isec->owner))
11516     {
11517       htab->toc_curr = elf_gp (isec->owner);
11518       htab->toc_first_sec = isec;
11519     }
11520   addr = (htab->toc_first_sec->output_offset
11521           + htab->toc_first_sec->output_section->vma);
11522   off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11523   elf_gp (isec->owner) = off;
11524
11525   return TRUE;
11526 }
11527
11528 /* Called via elf_link_hash_traverse to merge GOT entries for global
11529    symbol H.  */
11530
11531 static bfd_boolean
11532 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11533 {
11534   if (h->root.type == bfd_link_hash_indirect)
11535     return TRUE;
11536
11537   merge_got_entries (&h->got.glist);
11538
11539   return TRUE;
11540 }
11541
11542 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11543    symbol H.  */
11544
11545 static bfd_boolean
11546 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11547 {
11548   struct got_entry *gent;
11549
11550   if (h->root.type == bfd_link_hash_indirect)
11551     return TRUE;
11552
11553   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11554     if (!gent->is_indirect)
11555       allocate_got (h, (struct bfd_link_info *) inf, gent);
11556   return TRUE;
11557 }
11558
11559 /* Called on the first multitoc pass after the last call to
11560    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11561    entries.  */
11562
11563 bfd_boolean
11564 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11565 {
11566   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11567   struct bfd *ibfd, *ibfd2;
11568   bfd_boolean done_something;
11569
11570   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11571
11572   if (!htab->do_multi_toc)
11573     return FALSE;
11574
11575   /* Merge global sym got entries within a toc group.  */
11576   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11577
11578   /* And tlsld_got.  */
11579   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11580     {
11581       struct got_entry *ent, *ent2;
11582
11583       if (!is_ppc64_elf (ibfd))
11584         continue;
11585
11586       ent = ppc64_tlsld_got (ibfd);
11587       if (!ent->is_indirect
11588           && ent->got.offset != (bfd_vma) -1)
11589         {
11590           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11591             {
11592               if (!is_ppc64_elf (ibfd2))
11593                 continue;
11594
11595               ent2 = ppc64_tlsld_got (ibfd2);
11596               if (!ent2->is_indirect
11597                   && ent2->got.offset != (bfd_vma) -1
11598                   && elf_gp (ibfd2) == elf_gp (ibfd))
11599                 {
11600                   ent2->is_indirect = TRUE;
11601                   ent2->got.ent = ent;
11602                 }
11603             }
11604         }
11605     }
11606
11607   /* Zap sizes of got sections.  */
11608   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11609   htab->elf.irelplt->size -= htab->got_reli_size;
11610   htab->got_reli_size = 0;
11611
11612   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11613     {
11614       asection *got, *relgot;
11615
11616       if (!is_ppc64_elf (ibfd))
11617         continue;
11618
11619       got = ppc64_elf_tdata (ibfd)->got;
11620       if (got != NULL)
11621         {
11622           got->rawsize = got->size;
11623           got->size = 0;
11624           relgot = ppc64_elf_tdata (ibfd)->relgot;
11625           relgot->rawsize = relgot->size;
11626           relgot->size = 0;
11627         }
11628     }
11629
11630   /* Now reallocate the got, local syms first.  We don't need to
11631      allocate section contents again since we never increase size.  */
11632   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11633     {
11634       struct got_entry **lgot_ents;
11635       struct got_entry **end_lgot_ents;
11636       struct plt_entry **local_plt;
11637       struct plt_entry **end_local_plt;
11638       unsigned char *lgot_masks;
11639       bfd_size_type locsymcount;
11640       Elf_Internal_Shdr *symtab_hdr;
11641       asection *s;
11642
11643       if (!is_ppc64_elf (ibfd))
11644         continue;
11645
11646       lgot_ents = elf_local_got_ents (ibfd);
11647       if (!lgot_ents)
11648         continue;
11649
11650       symtab_hdr = &elf_symtab_hdr (ibfd);
11651       locsymcount = symtab_hdr->sh_info;
11652       end_lgot_ents = lgot_ents + locsymcount;
11653       local_plt = (struct plt_entry **) end_lgot_ents;
11654       end_local_plt = local_plt + locsymcount;
11655       lgot_masks = (unsigned char *) end_local_plt;
11656       s = ppc64_elf_tdata (ibfd)->got;
11657       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11658         {
11659           struct got_entry *ent;
11660
11661           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11662             {
11663               unsigned int ent_size = 8;
11664               unsigned int rel_size = sizeof (Elf64_External_Rela);
11665
11666               ent->got.offset = s->size;
11667               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11668                 {
11669                   ent_size *= 2;
11670                   rel_size *= 2;
11671                 }
11672               s->size += ent_size;
11673               if ((*lgot_masks & PLT_IFUNC) != 0)
11674                 {
11675                   htab->elf.irelplt->size += rel_size;
11676                   htab->got_reli_size += rel_size;
11677                 }
11678               else if (bfd_link_pic (info))
11679                 {
11680                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11681                   srel->size += rel_size;
11682                 }
11683             }
11684         }
11685     }
11686
11687   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11688
11689   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11690     {
11691       struct got_entry *ent;
11692
11693       if (!is_ppc64_elf (ibfd))
11694         continue;
11695
11696       ent = ppc64_tlsld_got (ibfd);
11697       if (!ent->is_indirect
11698           && ent->got.offset != (bfd_vma) -1)
11699         {
11700           asection *s = ppc64_elf_tdata (ibfd)->got;
11701           ent->got.offset = s->size;
11702           s->size += 16;
11703           if (bfd_link_pic (info))
11704             {
11705               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11706               srel->size += sizeof (Elf64_External_Rela);
11707             }
11708         }
11709     }
11710
11711   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11712   if (!done_something)
11713     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11714       {
11715         asection *got;
11716
11717         if (!is_ppc64_elf (ibfd))
11718           continue;
11719
11720         got = ppc64_elf_tdata (ibfd)->got;
11721         if (got != NULL)
11722           {
11723             done_something = got->rawsize != got->size;
11724             if (done_something)
11725               break;
11726           }
11727       }
11728
11729   if (done_something)
11730     (*htab->params->layout_sections_again) ();
11731
11732   /* Set up for second pass over toc sections to recalculate elf_gp
11733      on input sections.  */
11734   htab->toc_bfd = NULL;
11735   htab->toc_first_sec = NULL;
11736   htab->second_toc_pass = TRUE;
11737   return done_something;
11738 }
11739
11740 /* Called after second pass of multitoc partitioning.  */
11741
11742 void
11743 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11744 {
11745   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11746
11747   /* After the second pass, toc_curr tracks the TOC offset used
11748      for code sections below in ppc64_elf_next_input_section.  */
11749   htab->toc_curr = TOC_BASE_OFF;
11750 }
11751
11752 /* No toc references were found in ISEC.  If the code in ISEC makes no
11753    calls, then there's no need to use toc adjusting stubs when branching
11754    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11755    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11756    needed, and 2 if a cyclical call-graph was found but no other reason
11757    for a stub was detected.  If called from the top level, a return of
11758    2 means the same as a return of 0.  */
11759
11760 static int
11761 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11762 {
11763   int ret;
11764
11765   /* Mark this section as checked.  */
11766   isec->call_check_done = 1;
11767
11768   /* We know none of our code bearing sections will need toc stubs.  */
11769   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11770     return 0;
11771
11772   if (isec->size == 0)
11773     return 0;
11774
11775   if (isec->output_section == NULL)
11776     return 0;
11777
11778   ret = 0;
11779   if (isec->reloc_count != 0)
11780     {
11781       Elf_Internal_Rela *relstart, *rel;
11782       Elf_Internal_Sym *local_syms;
11783       struct ppc_link_hash_table *htab;
11784
11785       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11786                                             info->keep_memory);
11787       if (relstart == NULL)
11788         return -1;
11789
11790       /* Look for branches to outside of this section.  */
11791       local_syms = NULL;
11792       htab = ppc_hash_table (info);
11793       if (htab == NULL)
11794         return -1;
11795
11796       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11797         {
11798           enum elf_ppc64_reloc_type r_type;
11799           unsigned long r_symndx;
11800           struct elf_link_hash_entry *h;
11801           struct ppc_link_hash_entry *eh;
11802           Elf_Internal_Sym *sym;
11803           asection *sym_sec;
11804           struct _opd_sec_data *opd;
11805           bfd_vma sym_value;
11806           bfd_vma dest;
11807
11808           r_type = ELF64_R_TYPE (rel->r_info);
11809           if (r_type != R_PPC64_REL24
11810               && r_type != R_PPC64_REL14
11811               && r_type != R_PPC64_REL14_BRTAKEN
11812               && r_type != R_PPC64_REL14_BRNTAKEN)
11813             continue;
11814
11815           r_symndx = ELF64_R_SYM (rel->r_info);
11816           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11817                           isec->owner))
11818             {
11819               ret = -1;
11820               break;
11821             }
11822
11823           /* Calls to dynamic lib functions go through a plt call stub
11824              that uses r2.  */
11825           eh = (struct ppc_link_hash_entry *) h;
11826           if (eh != NULL
11827               && (eh->elf.plt.plist != NULL
11828                   || (eh->oh != NULL
11829                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11830             {
11831               ret = 1;
11832               break;
11833             }
11834
11835           if (sym_sec == NULL)
11836             /* Ignore other undefined symbols.  */
11837             continue;
11838
11839           /* Assume branches to other sections not included in the
11840              link need stubs too, to cover -R and absolute syms.  */
11841           if (sym_sec->output_section == NULL)
11842             {
11843               ret = 1;
11844               break;
11845             }
11846
11847           if (h == NULL)
11848             sym_value = sym->st_value;
11849           else
11850             {
11851               if (h->root.type != bfd_link_hash_defined
11852                   && h->root.type != bfd_link_hash_defweak)
11853                 abort ();
11854               sym_value = h->root.u.def.value;
11855             }
11856           sym_value += rel->r_addend;
11857
11858           /* If this branch reloc uses an opd sym, find the code section.  */
11859           opd = get_opd_info (sym_sec);
11860           if (opd != NULL)
11861             {
11862               if (h == NULL && opd->adjust != NULL)
11863                 {
11864                   long adjust;
11865
11866                   adjust = opd->adjust[OPD_NDX (sym_value)];
11867                   if (adjust == -1)
11868                     /* Assume deleted functions won't ever be called.  */
11869                     continue;
11870                   sym_value += adjust;
11871                 }
11872
11873               dest = opd_entry_value (sym_sec, sym_value,
11874                                       &sym_sec, NULL, FALSE);
11875               if (dest == (bfd_vma) -1)
11876                 continue;
11877             }
11878           else
11879             dest = (sym_value
11880                     + sym_sec->output_offset
11881                     + sym_sec->output_section->vma);
11882
11883           /* Ignore branch to self.  */
11884           if (sym_sec == isec)
11885             continue;
11886
11887           /* If the called function uses the toc, we need a stub.  */
11888           if (sym_sec->has_toc_reloc
11889               || sym_sec->makes_toc_func_call)
11890             {
11891               ret = 1;
11892               break;
11893             }
11894
11895           /* Assume any branch that needs a long branch stub might in fact
11896              need a plt_branch stub.  A plt_branch stub uses r2.  */
11897           else if (dest - (isec->output_offset
11898                            + isec->output_section->vma
11899                            + rel->r_offset) + (1 << 25)
11900                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11901                                                              ? h->other
11902                                                              : sym->st_other))
11903             {
11904               ret = 1;
11905               break;
11906             }
11907
11908           /* If calling back to a section in the process of being
11909              tested, we can't say for sure that no toc adjusting stubs
11910              are needed, so don't return zero.  */
11911           else if (sym_sec->call_check_in_progress)
11912             ret = 2;
11913
11914           /* Branches to another section that itself doesn't have any TOC
11915              references are OK.  Recursively call ourselves to check.  */
11916           else if (!sym_sec->call_check_done)
11917             {
11918               int recur;
11919
11920               /* Mark current section as indeterminate, so that other
11921                  sections that call back to current won't be marked as
11922                  known.  */
11923               isec->call_check_in_progress = 1;
11924               recur = toc_adjusting_stub_needed (info, sym_sec);
11925               isec->call_check_in_progress = 0;
11926
11927               if (recur != 0)
11928                 {
11929                   ret = recur;
11930                   if (recur != 2)
11931                     break;
11932                 }
11933             }
11934         }
11935
11936       if (local_syms != NULL
11937           && (elf_symtab_hdr (isec->owner).contents
11938               != (unsigned char *) local_syms))
11939         free (local_syms);
11940       if (elf_section_data (isec)->relocs != relstart)
11941         free (relstart);
11942     }
11943
11944   if ((ret & 1) == 0
11945       && isec->map_head.s != NULL
11946       && (strcmp (isec->output_section->name, ".init") == 0
11947           || strcmp (isec->output_section->name, ".fini") == 0))
11948     {
11949       if (isec->map_head.s->has_toc_reloc
11950           || isec->map_head.s->makes_toc_func_call)
11951         ret = 1;
11952       else if (!isec->map_head.s->call_check_done)
11953         {
11954           int recur;
11955           isec->call_check_in_progress = 1;
11956           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11957           isec->call_check_in_progress = 0;
11958           if (recur != 0)
11959             ret = recur;
11960         }
11961     }
11962
11963   if (ret == 1)
11964     isec->makes_toc_func_call = 1;
11965
11966   return ret;
11967 }
11968
11969 /* The linker repeatedly calls this function for each input section,
11970    in the order that input sections are linked into output sections.
11971    Build lists of input sections to determine groupings between which
11972    we may insert linker stubs.  */
11973
11974 bfd_boolean
11975 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11976 {
11977   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11978
11979   if (htab == NULL)
11980     return FALSE;
11981
11982   if ((isec->output_section->flags & SEC_CODE) != 0
11983       && isec->output_section->id < htab->sec_info_arr_size)
11984     {
11985       /* This happens to make the list in reverse order,
11986          which is what we want.  */
11987       htab->sec_info[isec->id].u.list
11988         = htab->sec_info[isec->output_section->id].u.list;
11989       htab->sec_info[isec->output_section->id].u.list = isec;
11990     }
11991
11992   if (htab->multi_toc_needed)
11993     {
11994       /* Analyse sections that aren't already flagged as needing a
11995          valid toc pointer.  Exclude .fixup for the linux kernel.
11996          .fixup contains branches, but only back to the function that
11997          hit an exception.  */
11998       if (!(isec->has_toc_reloc
11999             || (isec->flags & SEC_CODE) == 0
12000             || strcmp (isec->name, ".fixup") == 0
12001             || isec->call_check_done))
12002         {
12003           if (toc_adjusting_stub_needed (info, isec) < 0)
12004             return FALSE;
12005         }
12006       /* Make all sections use the TOC assigned for this object file.
12007          This will be wrong for pasted sections;  We fix that in
12008          check_pasted_section().  */
12009       if (elf_gp (isec->owner) != 0)
12010         htab->toc_curr = elf_gp (isec->owner);
12011     }
12012
12013   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12014   return TRUE;
12015 }
12016
12017 /* Check that all .init and .fini sections use the same toc, if they
12018    have toc relocs.  */
12019
12020 static bfd_boolean
12021 check_pasted_section (struct bfd_link_info *info, const char *name)
12022 {
12023   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12024
12025   if (o != NULL)
12026     {
12027       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12028       bfd_vma toc_off = 0;
12029       asection *i;
12030
12031       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12032         if (i->has_toc_reloc)
12033           {
12034             if (toc_off == 0)
12035               toc_off = htab->sec_info[i->id].toc_off;
12036             else if (toc_off != htab->sec_info[i->id].toc_off)
12037               return FALSE;
12038           }
12039
12040       if (toc_off == 0)
12041         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12042           if (i->makes_toc_func_call)
12043             {
12044               toc_off = htab->sec_info[i->id].toc_off;
12045               break;
12046             }
12047
12048       /* Make sure the whole pasted function uses the same toc offset.  */
12049       if (toc_off != 0)
12050         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12051           htab->sec_info[i->id].toc_off = toc_off;
12052     }
12053   return TRUE;
12054 }
12055
12056 bfd_boolean
12057 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12058 {
12059   return (check_pasted_section (info, ".init")
12060           & check_pasted_section (info, ".fini"));
12061 }
12062
12063 /* See whether we can group stub sections together.  Grouping stub
12064    sections may result in fewer stubs.  More importantly, we need to
12065    put all .init* and .fini* stubs at the beginning of the .init or
12066    .fini output sections respectively, because glibc splits the
12067    _init and _fini functions into multiple parts.  Putting a stub in
12068    the middle of a function is not a good idea.  */
12069
12070 static bfd_boolean
12071 group_sections (struct bfd_link_info *info,
12072                 bfd_size_type stub_group_size,
12073                 bfd_boolean stubs_always_before_branch)
12074 {
12075   struct ppc_link_hash_table *htab;
12076   asection *osec;
12077   bfd_boolean suppress_size_errors;
12078
12079   htab = ppc_hash_table (info);
12080   if (htab == NULL)
12081     return FALSE;
12082
12083   suppress_size_errors = FALSE;
12084   if (stub_group_size == 1)
12085     {
12086       /* Default values.  */
12087       if (stubs_always_before_branch)
12088         stub_group_size = 0x1e00000;
12089       else
12090         stub_group_size = 0x1c00000;
12091       suppress_size_errors = TRUE;
12092     }
12093
12094   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12095     {
12096       asection *tail;
12097
12098       if (osec->id >= htab->sec_info_arr_size)
12099         continue;
12100
12101       tail = htab->sec_info[osec->id].u.list;
12102       while (tail != NULL)
12103         {
12104           asection *curr;
12105           asection *prev;
12106           bfd_size_type total;
12107           bfd_boolean big_sec;
12108           bfd_vma curr_toc;
12109           struct map_stub *group;
12110           bfd_size_type group_size;
12111
12112           curr = tail;
12113           total = tail->size;
12114           group_size = (ppc64_elf_section_data (tail) != NULL
12115                         && ppc64_elf_section_data (tail)->has_14bit_branch
12116                         ? stub_group_size >> 10 : stub_group_size);
12117
12118           big_sec = total > group_size;
12119           if (big_sec && !suppress_size_errors)
12120             /* xgettext:c-format */
12121             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12122                                 tail->owner, tail);
12123           curr_toc = htab->sec_info[tail->id].toc_off;
12124
12125           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12126                  && ((total += curr->output_offset - prev->output_offset)
12127                      < (ppc64_elf_section_data (prev) != NULL
12128                         && ppc64_elf_section_data (prev)->has_14bit_branch
12129                         ? (group_size = stub_group_size >> 10) : group_size))
12130                  && htab->sec_info[prev->id].toc_off == curr_toc)
12131             curr = prev;
12132
12133           /* OK, the size from the start of CURR to the end is less
12134              than group_size and thus can be handled by one stub
12135              section.  (or the tail section is itself larger than
12136              group_size, in which case we may be toast.)  We should
12137              really be keeping track of the total size of stubs added
12138              here, as stubs contribute to the final output section
12139              size.  That's a little tricky, and this way will only
12140              break if stubs added make the total size more than 2^25,
12141              ie. for the default stub_group_size, if stubs total more
12142              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12143           group = bfd_alloc (curr->owner, sizeof (*group));
12144           if (group == NULL)
12145             return FALSE;
12146           group->link_sec = curr;
12147           group->stub_sec = NULL;
12148           group->needs_save_res = 0;
12149           group->tls_get_addr_opt_bctrl = -1u;
12150           group->next = htab->group;
12151           htab->group = group;
12152           do
12153             {
12154               prev = htab->sec_info[tail->id].u.list;
12155               /* Set up this stub group.  */
12156               htab->sec_info[tail->id].u.group = group;
12157             }
12158           while (tail != curr && (tail = prev) != NULL);
12159
12160           /* But wait, there's more!  Input sections up to group_size
12161              bytes before the stub section can be handled by it too.
12162              Don't do this if we have a really large section after the
12163              stubs, as adding more stubs increases the chance that
12164              branches may not reach into the stub section.  */
12165           if (!stubs_always_before_branch && !big_sec)
12166             {
12167               total = 0;
12168               while (prev != NULL
12169                      && ((total += tail->output_offset - prev->output_offset)
12170                          < (ppc64_elf_section_data (prev) != NULL
12171                             && ppc64_elf_section_data (prev)->has_14bit_branch
12172                             ? (group_size = stub_group_size >> 10) : group_size))
12173                      && htab->sec_info[prev->id].toc_off == curr_toc)
12174                 {
12175                   tail = prev;
12176                   prev = htab->sec_info[tail->id].u.list;
12177                   htab->sec_info[tail->id].u.group = group;
12178                 }
12179             }
12180           tail = prev;
12181         }
12182     }
12183   return TRUE;
12184 }
12185
12186 static const unsigned char glink_eh_frame_cie[] =
12187 {
12188   0, 0, 0, 16,                          /* length.  */
12189   0, 0, 0, 0,                           /* id.  */
12190   1,                                    /* CIE version.  */
12191   'z', 'R', 0,                          /* Augmentation string.  */
12192   4,                                    /* Code alignment.  */
12193   0x78,                                 /* Data alignment.  */
12194   65,                                   /* RA reg.  */
12195   1,                                    /* Augmentation size.  */
12196   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12197   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12198 };
12199
12200 static size_t
12201 stub_eh_frame_size (struct map_stub *group, size_t align)
12202 {
12203   size_t this_size = 17;
12204   if (group->tls_get_addr_opt_bctrl != -1u)
12205     {
12206       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12207       if (to_bctrl < 64)
12208         this_size += 1;
12209       else if (to_bctrl < 256)
12210         this_size += 2;
12211       else if (to_bctrl < 65536)
12212         this_size += 3;
12213       else
12214         this_size += 5;
12215       this_size += 6;
12216     }
12217   this_size = (this_size + align - 1) & -align;
12218   return this_size;
12219 }
12220
12221 /* Stripping output sections is normally done before dynamic section
12222    symbols have been allocated.  This function is called later, and
12223    handles cases like htab->brlt which is mapped to its own output
12224    section.  */
12225
12226 static void
12227 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12228 {
12229   if (isec->size == 0
12230       && isec->output_section->size == 0
12231       && !(isec->output_section->flags & SEC_KEEP)
12232       && !bfd_section_removed_from_list (info->output_bfd,
12233                                          isec->output_section)
12234       && elf_section_data (isec->output_section)->dynindx == 0)
12235     {
12236       isec->output_section->flags |= SEC_EXCLUDE;
12237       bfd_section_list_remove (info->output_bfd, isec->output_section);
12238       info->output_bfd->section_count--;
12239     }
12240 }
12241
12242 /* Determine and set the size of the stub section for a final link.
12243
12244    The basic idea here is to examine all the relocations looking for
12245    PC-relative calls to a target that is unreachable with a "bl"
12246    instruction.  */
12247
12248 bfd_boolean
12249 ppc64_elf_size_stubs (struct bfd_link_info *info)
12250 {
12251   bfd_size_type stub_group_size;
12252   bfd_boolean stubs_always_before_branch;
12253   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12254
12255   if (htab == NULL)
12256     return FALSE;
12257
12258   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12259     htab->params->plt_thread_safe = 1;
12260   if (!htab->opd_abi)
12261     htab->params->plt_thread_safe = 0;
12262   else if (htab->params->plt_thread_safe == -1)
12263     {
12264       static const char *const thread_starter[] =
12265         {
12266           "pthread_create",
12267           /* libstdc++ */
12268           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12269           /* librt */
12270           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12271           "mq_notify", "create_timer",
12272           /* libanl */
12273           "getaddrinfo_a",
12274           /* libgomp */
12275           "GOMP_parallel",
12276           "GOMP_parallel_start",
12277           "GOMP_parallel_loop_static",
12278           "GOMP_parallel_loop_static_start",
12279           "GOMP_parallel_loop_dynamic",
12280           "GOMP_parallel_loop_dynamic_start",
12281           "GOMP_parallel_loop_guided",
12282           "GOMP_parallel_loop_guided_start",
12283           "GOMP_parallel_loop_runtime",
12284           "GOMP_parallel_loop_runtime_start",
12285           "GOMP_parallel_sections",
12286           "GOMP_parallel_sections_start",
12287           /* libgo */
12288           "__go_go",
12289         };
12290       unsigned i;
12291
12292       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12293         {
12294           struct elf_link_hash_entry *h;
12295           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12296                                     FALSE, FALSE, TRUE);
12297           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12298           if (htab->params->plt_thread_safe)
12299             break;
12300         }
12301     }
12302   stubs_always_before_branch = htab->params->group_size < 0;
12303   if (htab->params->group_size < 0)
12304     stub_group_size = -htab->params->group_size;
12305   else
12306     stub_group_size = htab->params->group_size;
12307
12308   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12309     return FALSE;
12310
12311 #define STUB_SHRINK_ITER 20
12312   /* Loop until no stubs added.  After iteration 20 of this loop we may
12313      exit on a stub section shrinking.  This is to break out of a
12314      pathological case where adding stubs on one iteration decreases
12315      section gaps (perhaps due to alignment), which then requires
12316      fewer or smaller stubs on the next iteration.  */
12317
12318   while (1)
12319     {
12320       bfd *input_bfd;
12321       unsigned int bfd_indx;
12322       struct map_stub *group;
12323
12324       htab->stub_iteration += 1;
12325
12326       for (input_bfd = info->input_bfds, bfd_indx = 0;
12327            input_bfd != NULL;
12328            input_bfd = input_bfd->link.next, bfd_indx++)
12329         {
12330           Elf_Internal_Shdr *symtab_hdr;
12331           asection *section;
12332           Elf_Internal_Sym *local_syms = NULL;
12333
12334           if (!is_ppc64_elf (input_bfd))
12335             continue;
12336
12337           /* We'll need the symbol table in a second.  */
12338           symtab_hdr = &elf_symtab_hdr (input_bfd);
12339           if (symtab_hdr->sh_info == 0)
12340             continue;
12341
12342           /* Walk over each section attached to the input bfd.  */
12343           for (section = input_bfd->sections;
12344                section != NULL;
12345                section = section->next)
12346             {
12347               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12348
12349               /* If there aren't any relocs, then there's nothing more
12350                  to do.  */
12351               if ((section->flags & SEC_RELOC) == 0
12352                   || (section->flags & SEC_ALLOC) == 0
12353                   || (section->flags & SEC_LOAD) == 0
12354                   || (section->flags & SEC_CODE) == 0
12355                   || section->reloc_count == 0)
12356                 continue;
12357
12358               /* If this section is a link-once section that will be
12359                  discarded, then don't create any stubs.  */
12360               if (section->output_section == NULL
12361                   || section->output_section->owner != info->output_bfd)
12362                 continue;
12363
12364               /* Get the relocs.  */
12365               internal_relocs
12366                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12367                                              info->keep_memory);
12368               if (internal_relocs == NULL)
12369                 goto error_ret_free_local;
12370
12371               /* Now examine each relocation.  */
12372               irela = internal_relocs;
12373               irelaend = irela + section->reloc_count;
12374               for (; irela < irelaend; irela++)
12375                 {
12376                   enum elf_ppc64_reloc_type r_type;
12377                   unsigned int r_indx;
12378                   enum ppc_stub_type stub_type;
12379                   struct ppc_stub_hash_entry *stub_entry;
12380                   asection *sym_sec, *code_sec;
12381                   bfd_vma sym_value, code_value;
12382                   bfd_vma destination;
12383                   unsigned long local_off;
12384                   bfd_boolean ok_dest;
12385                   struct ppc_link_hash_entry *hash;
12386                   struct ppc_link_hash_entry *fdh;
12387                   struct elf_link_hash_entry *h;
12388                   Elf_Internal_Sym *sym;
12389                   char *stub_name;
12390                   const asection *id_sec;
12391                   struct _opd_sec_data *opd;
12392                   struct plt_entry *plt_ent;
12393
12394                   r_type = ELF64_R_TYPE (irela->r_info);
12395                   r_indx = ELF64_R_SYM (irela->r_info);
12396
12397                   if (r_type >= R_PPC64_max)
12398                     {
12399                       bfd_set_error (bfd_error_bad_value);
12400                       goto error_ret_free_internal;
12401                     }
12402
12403                   /* Only look for stubs on branch instructions.  */
12404                   if (r_type != R_PPC64_REL24
12405                       && r_type != R_PPC64_REL14
12406                       && r_type != R_PPC64_REL14_BRTAKEN
12407                       && r_type != R_PPC64_REL14_BRNTAKEN)
12408                     continue;
12409
12410                   /* Now determine the call target, its name, value,
12411                      section.  */
12412                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12413                                   r_indx, input_bfd))
12414                     goto error_ret_free_internal;
12415                   hash = (struct ppc_link_hash_entry *) h;
12416
12417                   ok_dest = FALSE;
12418                   fdh = NULL;
12419                   sym_value = 0;
12420                   if (hash == NULL)
12421                     {
12422                       sym_value = sym->st_value;
12423                       if (sym_sec != NULL
12424                           && sym_sec->output_section != NULL)
12425                         ok_dest = TRUE;
12426                     }
12427                   else if (hash->elf.root.type == bfd_link_hash_defined
12428                            || hash->elf.root.type == bfd_link_hash_defweak)
12429                     {
12430                       sym_value = hash->elf.root.u.def.value;
12431                       if (sym_sec->output_section != NULL)
12432                         ok_dest = TRUE;
12433                     }
12434                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12435                            || hash->elf.root.type == bfd_link_hash_undefined)
12436                     {
12437                       /* Recognise an old ABI func code entry sym, and
12438                          use the func descriptor sym instead if it is
12439                          defined.  */
12440                       if (hash->elf.root.root.string[0] == '.'
12441                           && hash->oh != NULL)
12442                         {
12443                           fdh = ppc_follow_link (hash->oh);
12444                           if (fdh->elf.root.type == bfd_link_hash_defined
12445                               || fdh->elf.root.type == bfd_link_hash_defweak)
12446                             {
12447                               sym_sec = fdh->elf.root.u.def.section;
12448                               sym_value = fdh->elf.root.u.def.value;
12449                               if (sym_sec->output_section != NULL)
12450                                 ok_dest = TRUE;
12451                             }
12452                           else
12453                             fdh = NULL;
12454                         }
12455                     }
12456                   else
12457                     {
12458                       bfd_set_error (bfd_error_bad_value);
12459                       goto error_ret_free_internal;
12460                     }
12461
12462                   destination = 0;
12463                   local_off = 0;
12464                   if (ok_dest)
12465                     {
12466                       sym_value += irela->r_addend;
12467                       destination = (sym_value
12468                                      + sym_sec->output_offset
12469                                      + sym_sec->output_section->vma);
12470                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12471                                                             ? hash->elf.other
12472                                                             : sym->st_other);
12473                     }
12474
12475                   code_sec = sym_sec;
12476                   code_value = sym_value;
12477                   opd = get_opd_info (sym_sec);
12478                   if (opd != NULL)
12479                     {
12480                       bfd_vma dest;
12481
12482                       if (hash == NULL && opd->adjust != NULL)
12483                         {
12484                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12485                           if (adjust == -1)
12486                             continue;
12487                           code_value += adjust;
12488                           sym_value += adjust;
12489                         }
12490                       dest = opd_entry_value (sym_sec, sym_value,
12491                                               &code_sec, &code_value, FALSE);
12492                       if (dest != (bfd_vma) -1)
12493                         {
12494                           destination = dest;
12495                           if (fdh != NULL)
12496                             {
12497                               /* Fixup old ABI sym to point at code
12498                                  entry.  */
12499                               hash->elf.root.type = bfd_link_hash_defweak;
12500                               hash->elf.root.u.def.section = code_sec;
12501                               hash->elf.root.u.def.value = code_value;
12502                             }
12503                         }
12504                     }
12505
12506                   /* Determine what (if any) linker stub is needed.  */
12507                   plt_ent = NULL;
12508                   stub_type = ppc_type_of_stub (section, irela, &hash,
12509                                                 &plt_ent, destination,
12510                                                 local_off);
12511
12512                   if (stub_type != ppc_stub_plt_call)
12513                     {
12514                       /* Check whether we need a TOC adjusting stub.
12515                          Since the linker pastes together pieces from
12516                          different object files when creating the
12517                          _init and _fini functions, it may be that a
12518                          call to what looks like a local sym is in
12519                          fact a call needing a TOC adjustment.  */
12520                       if (code_sec != NULL
12521                           && code_sec->output_section != NULL
12522                           && (htab->sec_info[code_sec->id].toc_off
12523                               != htab->sec_info[section->id].toc_off)
12524                           && (code_sec->has_toc_reloc
12525                               || code_sec->makes_toc_func_call))
12526                         stub_type = ppc_stub_long_branch_r2off;
12527                     }
12528
12529                   if (stub_type == ppc_stub_none)
12530                     continue;
12531
12532                   /* __tls_get_addr calls might be eliminated.  */
12533                   if (stub_type != ppc_stub_plt_call
12534                       && hash != NULL
12535                       && (hash == htab->tls_get_addr
12536                           || hash == htab->tls_get_addr_fd)
12537                       && section->has_tls_reloc
12538                       && irela != internal_relocs)
12539                     {
12540                       /* Get tls info.  */
12541                       unsigned char *tls_mask;
12542
12543                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12544                                          irela - 1, input_bfd))
12545                         goto error_ret_free_internal;
12546                       if (*tls_mask != 0)
12547                         continue;
12548                     }
12549
12550                   if (stub_type == ppc_stub_plt_call)
12551                     {
12552                       if (!htab->opd_abi
12553                           && htab->params->plt_localentry0 != 0
12554                           && is_elfv2_localentry0 (&hash->elf))
12555                         htab->has_plt_localentry0 = 1;
12556                       else if (irela + 1 < irelaend
12557                                && irela[1].r_offset == irela->r_offset + 4
12558                                && (ELF64_R_TYPE (irela[1].r_info)
12559                                    == R_PPC64_TOCSAVE))
12560                         {
12561                           if (!tocsave_find (htab, INSERT,
12562                                              &local_syms, irela + 1, input_bfd))
12563                             goto error_ret_free_internal;
12564                         }
12565                       else
12566                         stub_type = ppc_stub_plt_call_r2save;
12567                     }
12568
12569                   /* Support for grouping stub sections.  */
12570                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12571
12572                   /* Get the name of this stub.  */
12573                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12574                   if (!stub_name)
12575                     goto error_ret_free_internal;
12576
12577                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12578                                                      stub_name, FALSE, FALSE);
12579                   if (stub_entry != NULL)
12580                     {
12581                       /* The proper stub has already been created.  */
12582                       free (stub_name);
12583                       if (stub_type == ppc_stub_plt_call_r2save)
12584                         stub_entry->stub_type = stub_type;
12585                       continue;
12586                     }
12587
12588                   stub_entry = ppc_add_stub (stub_name, section, info);
12589                   if (stub_entry == NULL)
12590                     {
12591                       free (stub_name);
12592                     error_ret_free_internal:
12593                       if (elf_section_data (section)->relocs == NULL)
12594                         free (internal_relocs);
12595                     error_ret_free_local:
12596                       if (local_syms != NULL
12597                           && (symtab_hdr->contents
12598                               != (unsigned char *) local_syms))
12599                         free (local_syms);
12600                       return FALSE;
12601                     }
12602
12603                   stub_entry->stub_type = stub_type;
12604                   if (stub_type != ppc_stub_plt_call
12605                       && stub_type != ppc_stub_plt_call_r2save)
12606                     {
12607                       stub_entry->target_value = code_value;
12608                       stub_entry->target_section = code_sec;
12609                     }
12610                   else
12611                     {
12612                       stub_entry->target_value = sym_value;
12613                       stub_entry->target_section = sym_sec;
12614                     }
12615                   stub_entry->h = hash;
12616                   stub_entry->plt_ent = plt_ent;
12617                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12618
12619                   if (stub_entry->h != NULL)
12620                     htab->stub_globals += 1;
12621                 }
12622
12623               /* We're done with the internal relocs, free them.  */
12624               if (elf_section_data (section)->relocs != internal_relocs)
12625                 free (internal_relocs);
12626             }
12627
12628           if (local_syms != NULL
12629               && symtab_hdr->contents != (unsigned char *) local_syms)
12630             {
12631               if (!info->keep_memory)
12632                 free (local_syms);
12633               else
12634                 symtab_hdr->contents = (unsigned char *) local_syms;
12635             }
12636         }
12637
12638       /* We may have added some stubs.  Find out the new size of the
12639          stub sections.  */
12640       for (group = htab->group; group != NULL; group = group->next)
12641         if (group->stub_sec != NULL)
12642           {
12643             asection *stub_sec = group->stub_sec;
12644
12645             if (htab->stub_iteration <= STUB_SHRINK_ITER
12646                 || stub_sec->rawsize < stub_sec->size)
12647               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12648               stub_sec->rawsize = stub_sec->size;
12649             stub_sec->size = 0;
12650             stub_sec->reloc_count = 0;
12651             stub_sec->flags &= ~SEC_RELOC;
12652           }
12653
12654       htab->brlt->size = 0;
12655       htab->brlt->reloc_count = 0;
12656       htab->brlt->flags &= ~SEC_RELOC;
12657       if (htab->relbrlt != NULL)
12658         htab->relbrlt->size = 0;
12659
12660       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12661
12662       for (group = htab->group; group != NULL; group = group->next)
12663         if (group->needs_save_res)
12664           group->stub_sec->size += htab->sfpr->size;
12665
12666       if (info->emitrelocations
12667           && htab->glink != NULL && htab->glink->size != 0)
12668         {
12669           htab->glink->reloc_count = 1;
12670           htab->glink->flags |= SEC_RELOC;
12671         }
12672
12673       if (htab->glink_eh_frame != NULL
12674           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12675           && htab->glink_eh_frame->output_section->size > 8)
12676         {
12677           size_t size = 0, align = 4;
12678
12679           for (group = htab->group; group != NULL; group = group->next)
12680             if (group->stub_sec != NULL)
12681               size += stub_eh_frame_size (group, align);
12682           if (htab->glink != NULL && htab->glink->size != 0)
12683             size += (24 + align - 1) & -align;
12684           if (size != 0)
12685             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12686           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12687           size = (size + align - 1) & -align;
12688           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12689           htab->glink_eh_frame->size = size;
12690         }
12691
12692       if (htab->params->plt_stub_align != 0)
12693         for (group = htab->group; group != NULL; group = group->next)
12694           if (group->stub_sec != NULL)
12695             group->stub_sec->size = ((group->stub_sec->size
12696                                       + (1 << htab->params->plt_stub_align) - 1)
12697                                      & -(1 << htab->params->plt_stub_align));
12698
12699       for (group = htab->group; group != NULL; group = group->next)
12700         if (group->stub_sec != NULL
12701             && group->stub_sec->rawsize != group->stub_sec->size
12702             && (htab->stub_iteration <= STUB_SHRINK_ITER
12703                 || group->stub_sec->rawsize < group->stub_sec->size))
12704           break;
12705
12706       if (group == NULL
12707           && (htab->glink_eh_frame == NULL
12708               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12709         break;
12710
12711       /* Ask the linker to do its stuff.  */
12712       (*htab->params->layout_sections_again) ();
12713     }
12714
12715   if (htab->glink_eh_frame != NULL
12716       && htab->glink_eh_frame->size != 0)
12717     {
12718       bfd_vma val;
12719       bfd_byte *p, *last_fde;
12720       size_t last_fde_len, size, align, pad;
12721       struct map_stub *group;
12722
12723       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12724       if (p == NULL)
12725         return FALSE;
12726       htab->glink_eh_frame->contents = p;
12727       last_fde = p;
12728       align = 4;
12729
12730       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12731       /* CIE length (rewrite in case little-endian).  */
12732       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12733       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12734       p += last_fde_len + 4;
12735
12736       for (group = htab->group; group != NULL; group = group->next)
12737         if (group->stub_sec != NULL)
12738           {
12739             last_fde = p;
12740             last_fde_len = stub_eh_frame_size (group, align) - 4;
12741             /* FDE length.  */
12742             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12743             p += 4;
12744             /* CIE pointer.  */
12745             val = p - htab->glink_eh_frame->contents;
12746             bfd_put_32 (htab->elf.dynobj, val, p);
12747             p += 4;
12748             /* Offset to stub section, written later.  */
12749             p += 4;
12750             /* stub section size.  */
12751             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12752             p += 4;
12753             /* Augmentation.  */
12754             p += 1;
12755             if (group->tls_get_addr_opt_bctrl != -1u)
12756               {
12757                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12758
12759                 /* This FDE needs more than just the default.
12760                    Describe __tls_get_addr_opt stub LR.  */
12761                 if (to_bctrl < 64)
12762                   *p++ = DW_CFA_advance_loc + to_bctrl;
12763                 else if (to_bctrl < 256)
12764                   {
12765                     *p++ = DW_CFA_advance_loc1;
12766                     *p++ = to_bctrl;
12767                   }
12768                 else if (to_bctrl < 65536)
12769                   {
12770                     *p++ = DW_CFA_advance_loc2;
12771                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12772                     p += 2;
12773                   }
12774                 else
12775                   {
12776                     *p++ = DW_CFA_advance_loc4;
12777                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12778                     p += 4;
12779                   }
12780                 *p++ = DW_CFA_offset_extended_sf;
12781                 *p++ = 65;
12782                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12783                 *p++ = DW_CFA_advance_loc + 4;
12784                 *p++ = DW_CFA_restore_extended;
12785                 *p++ = 65;
12786               }
12787             /* Pad.  */
12788             p = last_fde + last_fde_len + 4;
12789           }
12790       if (htab->glink != NULL && htab->glink->size != 0)
12791         {
12792           last_fde = p;
12793           last_fde_len = ((24 + align - 1) & -align) - 4;
12794           /* FDE length.  */
12795           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12796           p += 4;
12797           /* CIE pointer.  */
12798           val = p - htab->glink_eh_frame->contents;
12799           bfd_put_32 (htab->elf.dynobj, val, p);
12800           p += 4;
12801           /* Offset to .glink, written later.  */
12802           p += 4;
12803           /* .glink size.  */
12804           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12805           p += 4;
12806           /* Augmentation.  */
12807           p += 1;
12808
12809           *p++ = DW_CFA_advance_loc + 1;
12810           *p++ = DW_CFA_register;
12811           *p++ = 65;
12812           *p++ = htab->opd_abi ? 12 : 0;
12813           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12814           *p++ = DW_CFA_restore_extended;
12815           *p++ = 65;
12816           p += ((24 + align - 1) & -align) - 24;
12817         }
12818       /* Subsume any padding into the last FDE if user .eh_frame
12819          sections are aligned more than glink_eh_frame.  Otherwise any
12820          zero padding will be seen as a terminator.  */
12821       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12822       size = p - htab->glink_eh_frame->contents;
12823       pad = ((size + align - 1) & -align) - size;
12824       htab->glink_eh_frame->size = size + pad;
12825       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12826     }
12827
12828   maybe_strip_output (info, htab->brlt);
12829   if (htab->glink_eh_frame != NULL)
12830     maybe_strip_output (info, htab->glink_eh_frame);
12831
12832   return TRUE;
12833 }
12834
12835 /* Called after we have determined section placement.  If sections
12836    move, we'll be called again.  Provide a value for TOCstart.  */
12837
12838 bfd_vma
12839 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12840 {
12841   asection *s;
12842   bfd_vma TOCstart, adjust;
12843
12844   if (info != NULL)
12845     {
12846       struct elf_link_hash_entry *h;
12847       struct elf_link_hash_table *htab = elf_hash_table (info);
12848
12849       if (is_elf_hash_table (htab)
12850           && htab->hgot != NULL)
12851         h = htab->hgot;
12852       else
12853         {
12854           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12855           if (is_elf_hash_table (htab))
12856             htab->hgot = h;
12857         }
12858       if (h != NULL
12859           && h->root.type == bfd_link_hash_defined
12860           && !h->root.linker_def
12861           && (!is_elf_hash_table (htab)
12862               || h->def_regular))
12863         {
12864           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12865                       + h->root.u.def.section->output_offset
12866                       + h->root.u.def.section->output_section->vma);
12867           _bfd_set_gp_value (obfd, TOCstart);
12868           return TOCstart;
12869         }
12870     }
12871
12872   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12873      order.  The TOC starts where the first of these sections starts.  */
12874   s = bfd_get_section_by_name (obfd, ".got");
12875   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12876     s = bfd_get_section_by_name (obfd, ".toc");
12877   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12878     s = bfd_get_section_by_name (obfd, ".tocbss");
12879   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12880     s = bfd_get_section_by_name (obfd, ".plt");
12881   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12882     {
12883       /* This may happen for
12884          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12885          .toc directive
12886          o  bad linker script
12887          o --gc-sections and empty TOC sections
12888
12889          FIXME: Warn user?  */
12890
12891       /* Look for a likely section.  We probably won't even be
12892          using TOCstart.  */
12893       for (s = obfd->sections; s != NULL; s = s->next)
12894         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12895                          | SEC_EXCLUDE))
12896             == (SEC_ALLOC | SEC_SMALL_DATA))
12897           break;
12898       if (s == NULL)
12899         for (s = obfd->sections; s != NULL; s = s->next)
12900           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12901               == (SEC_ALLOC | SEC_SMALL_DATA))
12902             break;
12903       if (s == NULL)
12904         for (s = obfd->sections; s != NULL; s = s->next)
12905           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12906               == SEC_ALLOC)
12907             break;
12908       if (s == NULL)
12909         for (s = obfd->sections; s != NULL; s = s->next)
12910           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12911             break;
12912     }
12913
12914   TOCstart = 0;
12915   if (s != NULL)
12916     TOCstart = s->output_section->vma + s->output_offset;
12917
12918   /* Force alignment.  */
12919   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12920   TOCstart -= adjust;
12921   _bfd_set_gp_value (obfd, TOCstart);
12922
12923   if (info != NULL && s != NULL)
12924     {
12925       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12926
12927       if (htab != NULL)
12928         {
12929           if (htab->elf.hgot != NULL)
12930             {
12931               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12932               htab->elf.hgot->root.u.def.section = s;
12933             }
12934         }
12935       else
12936         {
12937           struct bfd_link_hash_entry *bh = NULL;
12938           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12939                                             s, TOC_BASE_OFF - adjust,
12940                                             NULL, FALSE, FALSE, &bh);
12941         }
12942     }
12943   return TOCstart;
12944 }
12945
12946 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12947    write out any global entry stubs.  */
12948
12949 static bfd_boolean
12950 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12951 {
12952   struct bfd_link_info *info;
12953   struct ppc_link_hash_table *htab;
12954   struct plt_entry *pent;
12955   asection *s;
12956
12957   if (h->root.type == bfd_link_hash_indirect)
12958     return TRUE;
12959
12960   if (!h->pointer_equality_needed)
12961     return TRUE;
12962
12963   if (h->def_regular)
12964     return TRUE;
12965
12966   info = inf;
12967   htab = ppc_hash_table (info);
12968   if (htab == NULL)
12969     return FALSE;
12970
12971   s = htab->glink;
12972   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12973     if (pent->plt.offset != (bfd_vma) -1
12974         && pent->addend == 0)
12975       {
12976         bfd_byte *p;
12977         asection *plt;
12978         bfd_vma off;
12979
12980         p = s->contents + h->root.u.def.value;
12981         plt = htab->elf.splt;
12982         if (!htab->elf.dynamic_sections_created
12983             || h->dynindx == -1)
12984           plt = htab->elf.iplt;
12985         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12986         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12987
12988         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12989           {
12990             info->callbacks->einfo
12991               (_("%P: linkage table error against `%T'\n"),
12992                h->root.root.string);
12993             bfd_set_error (bfd_error_bad_value);
12994             htab->stub_error = TRUE;
12995           }
12996
12997         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12998         if (htab->params->emit_stub_syms)
12999           {
13000             size_t len = strlen (h->root.root.string);
13001             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13002
13003             if (name == NULL)
13004               return FALSE;
13005
13006             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13007             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13008             if (h == NULL)
13009               return FALSE;
13010             if (h->root.type == bfd_link_hash_new)
13011               {
13012                 h->root.type = bfd_link_hash_defined;
13013                 h->root.u.def.section = s;
13014                 h->root.u.def.value = p - s->contents;
13015                 h->ref_regular = 1;
13016                 h->def_regular = 1;
13017                 h->ref_regular_nonweak = 1;
13018                 h->forced_local = 1;
13019                 h->non_elf = 0;
13020                 h->root.linker_def = 1;
13021               }
13022           }
13023
13024         if (PPC_HA (off) != 0)
13025           {
13026             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13027             p += 4;
13028           }
13029         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13030         p += 4;
13031         bfd_put_32 (s->owner, MTCTR_R12, p);
13032         p += 4;
13033         bfd_put_32 (s->owner, BCTR, p);
13034         break;
13035       }
13036   return TRUE;
13037 }
13038
13039 /* Build all the stubs associated with the current output file.
13040    The stubs are kept in a hash table attached to the main linker
13041    hash table.  This function is called via gldelf64ppc_finish.  */
13042
13043 bfd_boolean
13044 ppc64_elf_build_stubs (struct bfd_link_info *info,
13045                        char **stats)
13046 {
13047   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13048   struct map_stub *group;
13049   asection *stub_sec;
13050   bfd_byte *p;
13051   int stub_sec_count = 0;
13052
13053   if (htab == NULL)
13054     return FALSE;
13055
13056   /* Allocate memory to hold the linker stubs.  */
13057   for (group = htab->group; group != NULL; group = group->next)
13058     if ((stub_sec = group->stub_sec) != NULL
13059         && stub_sec->size != 0)
13060       {
13061         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13062         if (stub_sec->contents == NULL)
13063           return FALSE;
13064         stub_sec->size = 0;
13065       }
13066
13067   if (htab->glink != NULL && htab->glink->size != 0)
13068     {
13069       unsigned int indx;
13070       bfd_vma plt0;
13071
13072       /* Build the .glink plt call stub.  */
13073       if (htab->params->emit_stub_syms)
13074         {
13075           struct elf_link_hash_entry *h;
13076           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13077                                     TRUE, FALSE, FALSE);
13078           if (h == NULL)
13079             return FALSE;
13080           if (h->root.type == bfd_link_hash_new)
13081             {
13082               h->root.type = bfd_link_hash_defined;
13083               h->root.u.def.section = htab->glink;
13084               h->root.u.def.value = 8;
13085               h->ref_regular = 1;
13086               h->def_regular = 1;
13087               h->ref_regular_nonweak = 1;
13088               h->forced_local = 1;
13089               h->non_elf = 0;
13090               h->root.linker_def = 1;
13091             }
13092         }
13093       plt0 = (htab->elf.splt->output_section->vma
13094               + htab->elf.splt->output_offset
13095               - 16);
13096       if (info->emitrelocations)
13097         {
13098           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13099           if (r == NULL)
13100             return FALSE;
13101           r->r_offset = (htab->glink->output_offset
13102                          + htab->glink->output_section->vma);
13103           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13104           r->r_addend = plt0;
13105         }
13106       p = htab->glink->contents;
13107       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13108       bfd_put_64 (htab->glink->owner, plt0, p);
13109       p += 8;
13110       if (htab->opd_abi)
13111         {
13112           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13113           p += 4;
13114           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13115           p += 4;
13116           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13117           p += 4;
13118           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13119           p += 4;
13120           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13121           p += 4;
13122           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13123           p += 4;
13124           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13125           p += 4;
13126           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13127           p += 4;
13128           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13129           p += 4;
13130           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13131           p += 4;
13132         }
13133       else
13134         {
13135           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13136           p += 4;
13137           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13138           p += 4;
13139           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13140           p += 4;
13141           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13142           p += 4;
13143           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13144           p += 4;
13145           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13146           p += 4;
13147           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13148           p += 4;
13149           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13150           p += 4;
13151           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13152           p += 4;
13153           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13154           p += 4;
13155           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13156           p += 4;
13157           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13158           p += 4;
13159           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13160           p += 4;
13161         }
13162       bfd_put_32 (htab->glink->owner, BCTR, p);
13163       p += 4;
13164       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13165         {
13166           bfd_put_32 (htab->glink->owner, NOP, p);
13167           p += 4;
13168         }
13169
13170       /* Build the .glink lazy link call stubs.  */
13171       indx = 0;
13172       while (p < htab->glink->contents + htab->glink->rawsize)
13173         {
13174           if (htab->opd_abi)
13175             {
13176               if (indx < 0x8000)
13177                 {
13178                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13179                   p += 4;
13180                 }
13181               else
13182                 {
13183                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13184                   p += 4;
13185                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13186                               p);
13187                   p += 4;
13188                 }
13189             }
13190           bfd_put_32 (htab->glink->owner,
13191                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13192           indx++;
13193           p += 4;
13194         }
13195
13196       /* Build .glink global entry stubs.  */
13197       if (htab->glink->size > htab->glink->rawsize)
13198         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13199     }
13200
13201   if (htab->brlt != NULL && htab->brlt->size != 0)
13202     {
13203       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13204                                          htab->brlt->size);
13205       if (htab->brlt->contents == NULL)
13206         return FALSE;
13207     }
13208   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13209     {
13210       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13211                                             htab->relbrlt->size);
13212       if (htab->relbrlt->contents == NULL)
13213         return FALSE;
13214     }
13215
13216   /* Build the stubs as directed by the stub hash table.  */
13217   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13218
13219   for (group = htab->group; group != NULL; group = group->next)
13220     if (group->needs_save_res)
13221       {
13222         stub_sec = group->stub_sec;
13223         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13224                 htab->sfpr->size);
13225         if (htab->params->emit_stub_syms)
13226           {
13227             unsigned int i;
13228
13229             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13230               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13231                 return FALSE;
13232           }
13233         stub_sec->size += htab->sfpr->size;
13234       }
13235
13236   if (htab->relbrlt != NULL)
13237     htab->relbrlt->reloc_count = 0;
13238
13239   if (htab->params->plt_stub_align != 0)
13240     for (group = htab->group; group != NULL; group = group->next)
13241       if ((stub_sec = group->stub_sec) != NULL)
13242         stub_sec->size = ((stub_sec->size
13243                            + (1 << htab->params->plt_stub_align) - 1)
13244                           & -(1 << htab->params->plt_stub_align));
13245
13246   for (group = htab->group; group != NULL; group = group->next)
13247     if ((stub_sec = group->stub_sec) != NULL)
13248       {
13249         stub_sec_count += 1;
13250         if (stub_sec->rawsize != stub_sec->size
13251             && (htab->stub_iteration <= STUB_SHRINK_ITER
13252                 || stub_sec->rawsize < stub_sec->size))
13253           break;
13254       }
13255
13256   if (group != NULL)
13257     {
13258       htab->stub_error = TRUE;
13259       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13260     }
13261
13262   if (htab->stub_error)
13263     return FALSE;
13264
13265   if (stats != NULL)
13266     {
13267       size_t len;
13268       *stats = bfd_malloc (500);
13269       if (*stats == NULL)
13270         return FALSE;
13271
13272       len = sprintf (*stats,
13273                      ngettext ("linker stubs in %u group\n",
13274                                "linker stubs in %u groups\n",
13275                                stub_sec_count),
13276                      stub_sec_count);
13277       sprintf (*stats + len, _("  branch       %lu\n"
13278                                "  toc adjust   %lu\n"
13279                                "  long branch  %lu\n"
13280                                "  long toc adj %lu\n"
13281                                "  plt call     %lu\n"
13282                                "  plt call toc %lu\n"
13283                                "  global entry %lu"),
13284                htab->stub_count[ppc_stub_long_branch - 1],
13285                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13286                htab->stub_count[ppc_stub_plt_branch - 1],
13287                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13288                htab->stub_count[ppc_stub_plt_call - 1],
13289                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13290                htab->stub_count[ppc_stub_global_entry - 1]);
13291     }
13292   return TRUE;
13293 }
13294
13295 /* What to do when ld finds relocations against symbols defined in
13296    discarded sections.  */
13297
13298 static unsigned int
13299 ppc64_elf_action_discarded (asection *sec)
13300 {
13301   if (strcmp (".opd", sec->name) == 0)
13302     return 0;
13303
13304   if (strcmp (".toc", sec->name) == 0)
13305     return 0;
13306
13307   if (strcmp (".toc1", sec->name) == 0)
13308     return 0;
13309
13310   return _bfd_elf_default_action_discarded (sec);
13311 }
13312
13313 /* The RELOCATE_SECTION function is called by the ELF backend linker
13314    to handle the relocations for a section.
13315
13316    The relocs are always passed as Rela structures; if the section
13317    actually uses Rel structures, the r_addend field will always be
13318    zero.
13319
13320    This function is responsible for adjust the section contents as
13321    necessary, and (if using Rela relocs and generating a
13322    relocatable output file) adjusting the reloc addend as
13323    necessary.
13324
13325    This function does not have to worry about setting the reloc
13326    address or the reloc symbol index.
13327
13328    LOCAL_SYMS is a pointer to the swapped in local symbols.
13329
13330    LOCAL_SECTIONS is an array giving the section in the input file
13331    corresponding to the st_shndx field of each local symbol.
13332
13333    The global hash table entry for the global symbols can be found
13334    via elf_sym_hashes (input_bfd).
13335
13336    When generating relocatable output, this function must handle
13337    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13338    going to be the section symbol corresponding to the output
13339    section, which means that the addend must be adjusted
13340    accordingly.  */
13341
13342 static bfd_boolean
13343 ppc64_elf_relocate_section (bfd *output_bfd,
13344                             struct bfd_link_info *info,
13345                             bfd *input_bfd,
13346                             asection *input_section,
13347                             bfd_byte *contents,
13348                             Elf_Internal_Rela *relocs,
13349                             Elf_Internal_Sym *local_syms,
13350                             asection **local_sections)
13351 {
13352   struct ppc_link_hash_table *htab;
13353   Elf_Internal_Shdr *symtab_hdr;
13354   struct elf_link_hash_entry **sym_hashes;
13355   Elf_Internal_Rela *rel;
13356   Elf_Internal_Rela *wrel;
13357   Elf_Internal_Rela *relend;
13358   Elf_Internal_Rela outrel;
13359   bfd_byte *loc;
13360   struct got_entry **local_got_ents;
13361   bfd_vma TOCstart;
13362   bfd_boolean ret = TRUE;
13363   bfd_boolean is_opd;
13364   /* Assume 'at' branch hints.  */
13365   bfd_boolean is_isa_v2 = TRUE;
13366   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13367
13368   /* Initialize howto table if needed.  */
13369   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13370     ppc_howto_init ();
13371
13372   htab = ppc_hash_table (info);
13373   if (htab == NULL)
13374     return FALSE;
13375
13376   /* Don't relocate stub sections.  */
13377   if (input_section->owner == htab->params->stub_bfd)
13378     return TRUE;
13379
13380   BFD_ASSERT (is_ppc64_elf (input_bfd));
13381
13382   local_got_ents = elf_local_got_ents (input_bfd);
13383   TOCstart = elf_gp (output_bfd);
13384   symtab_hdr = &elf_symtab_hdr (input_bfd);
13385   sym_hashes = elf_sym_hashes (input_bfd);
13386   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13387
13388   rel = wrel = relocs;
13389   relend = relocs + input_section->reloc_count;
13390   for (; rel < relend; wrel++, rel++)
13391     {
13392       enum elf_ppc64_reloc_type r_type;
13393       bfd_vma addend;
13394       bfd_reloc_status_type r;
13395       Elf_Internal_Sym *sym;
13396       asection *sec;
13397       struct elf_link_hash_entry *h_elf;
13398       struct ppc_link_hash_entry *h;
13399       struct ppc_link_hash_entry *fdh;
13400       const char *sym_name;
13401       unsigned long r_symndx, toc_symndx;
13402       bfd_vma toc_addend;
13403       unsigned char tls_mask, tls_gd, tls_type;
13404       unsigned char sym_type;
13405       bfd_vma relocation;
13406       bfd_boolean unresolved_reloc;
13407       bfd_boolean warned;
13408       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13409       unsigned int insn;
13410       unsigned int mask;
13411       struct ppc_stub_hash_entry *stub_entry;
13412       bfd_vma max_br_offset;
13413       bfd_vma from;
13414       Elf_Internal_Rela orig_rel;
13415       reloc_howto_type *howto;
13416       struct reloc_howto_struct alt_howto;
13417
13418     again:
13419       orig_rel = *rel;
13420
13421       r_type = ELF64_R_TYPE (rel->r_info);
13422       r_symndx = ELF64_R_SYM (rel->r_info);
13423
13424       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13425          symbol of the previous ADDR64 reloc.  The symbol gives us the
13426          proper TOC base to use.  */
13427       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13428           && wrel != relocs
13429           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13430           && is_opd)
13431         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13432
13433       sym = NULL;
13434       sec = NULL;
13435       h_elf = NULL;
13436       sym_name = NULL;
13437       unresolved_reloc = FALSE;
13438       warned = FALSE;
13439
13440       if (r_symndx < symtab_hdr->sh_info)
13441         {
13442           /* It's a local symbol.  */
13443           struct _opd_sec_data *opd;
13444
13445           sym = local_syms + r_symndx;
13446           sec = local_sections[r_symndx];
13447           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13448           sym_type = ELF64_ST_TYPE (sym->st_info);
13449           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13450           opd = get_opd_info (sec);
13451           if (opd != NULL && opd->adjust != NULL)
13452             {
13453               long adjust = opd->adjust[OPD_NDX (sym->st_value
13454                                                  + rel->r_addend)];
13455               if (adjust == -1)
13456                 relocation = 0;
13457               else
13458                 {
13459                   /* If this is a relocation against the opd section sym
13460                      and we have edited .opd, adjust the reloc addend so
13461                      that ld -r and ld --emit-relocs output is correct.
13462                      If it is a reloc against some other .opd symbol,
13463                      then the symbol value will be adjusted later.  */
13464                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13465                     rel->r_addend += adjust;
13466                   else
13467                     relocation += adjust;
13468                 }
13469             }
13470         }
13471       else
13472         {
13473           bfd_boolean ignored;
13474
13475           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13476                                    r_symndx, symtab_hdr, sym_hashes,
13477                                    h_elf, sec, relocation,
13478                                    unresolved_reloc, warned, ignored);
13479           sym_name = h_elf->root.root.string;
13480           sym_type = h_elf->type;
13481           if (sec != NULL
13482               && sec->owner == output_bfd
13483               && strcmp (sec->name, ".opd") == 0)
13484             {
13485               /* This is a symbol defined in a linker script.  All
13486                  such are defined in output sections, even those
13487                  defined by simple assignment from a symbol defined in
13488                  an input section.  Transfer the symbol to an
13489                  appropriate input .opd section, so that a branch to
13490                  this symbol will be mapped to the location specified
13491                  by the opd entry.  */
13492               struct bfd_link_order *lo;
13493               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13494                 if (lo->type == bfd_indirect_link_order)
13495                   {
13496                     asection *isec = lo->u.indirect.section;
13497                     if (h_elf->root.u.def.value >= isec->output_offset
13498                         && h_elf->root.u.def.value < (isec->output_offset
13499                                                       + isec->size))
13500                       {
13501                         h_elf->root.u.def.value -= isec->output_offset;
13502                         h_elf->root.u.def.section = isec;
13503                         sec = isec;
13504                         break;
13505                       }
13506                   }
13507             }
13508         }
13509       h = (struct ppc_link_hash_entry *) h_elf;
13510
13511       if (sec != NULL && discarded_section (sec))
13512         {
13513           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13514                                input_bfd, input_section,
13515                                contents + rel->r_offset);
13516           wrel->r_offset = rel->r_offset;
13517           wrel->r_info = 0;
13518           wrel->r_addend = 0;
13519
13520           /* For ld -r, remove relocations in debug sections against
13521              symbols defined in discarded sections.  Not done for
13522              non-debug to preserve relocs in .eh_frame which the
13523              eh_frame editing code expects to be present.  */
13524           if (bfd_link_relocatable (info)
13525               && (input_section->flags & SEC_DEBUGGING))
13526             wrel--;
13527
13528           continue;
13529         }
13530
13531       if (bfd_link_relocatable (info))
13532         goto copy_reloc;
13533
13534       if (h != NULL && &h->elf == htab->elf.hgot)
13535         {
13536           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13537           sec = bfd_abs_section_ptr;
13538           unresolved_reloc = FALSE;
13539         }
13540
13541       /* TLS optimizations.  Replace instruction sequences and relocs
13542          based on information we collected in tls_optimize.  We edit
13543          RELOCS so that --emit-relocs will output something sensible
13544          for the final instruction stream.  */
13545       tls_mask = 0;
13546       tls_gd = 0;
13547       toc_symndx = 0;
13548       if (h != NULL)
13549         tls_mask = h->tls_mask;
13550       else if (local_got_ents != NULL)
13551         {
13552           struct plt_entry **local_plt = (struct plt_entry **)
13553             (local_got_ents + symtab_hdr->sh_info);
13554           unsigned char *lgot_masks = (unsigned char *)
13555             (local_plt + symtab_hdr->sh_info);
13556           tls_mask = lgot_masks[r_symndx];
13557         }
13558       if (tls_mask == 0
13559           && (r_type == R_PPC64_TLS
13560               || r_type == R_PPC64_TLSGD
13561               || r_type == R_PPC64_TLSLD))
13562         {
13563           /* Check for toc tls entries.  */
13564           unsigned char *toc_tls;
13565
13566           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13567                              &local_syms, rel, input_bfd))
13568             return FALSE;
13569
13570           if (toc_tls)
13571             tls_mask = *toc_tls;
13572         }
13573
13574       /* Check that tls relocs are used with tls syms, and non-tls
13575          relocs are used with non-tls syms.  */
13576       if (r_symndx != STN_UNDEF
13577           && r_type != R_PPC64_NONE
13578           && (h == NULL
13579               || h->elf.root.type == bfd_link_hash_defined
13580               || h->elf.root.type == bfd_link_hash_defweak)
13581           && (IS_PPC64_TLS_RELOC (r_type)
13582               != (sym_type == STT_TLS
13583                   || (sym_type == STT_SECTION
13584                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13585         {
13586           if (tls_mask != 0
13587               && (r_type == R_PPC64_TLS
13588                   || r_type == R_PPC64_TLSGD
13589                   || r_type == R_PPC64_TLSLD))
13590             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13591             ;
13592           else
13593             info->callbacks->einfo
13594               (!IS_PPC64_TLS_RELOC (r_type)
13595                /* xgettext:c-format */
13596                ? _("%H: %s used with TLS symbol `%T'\n")
13597                /* xgettext:c-format */
13598                : _("%H: %s used with non-TLS symbol `%T'\n"),
13599                input_bfd, input_section, rel->r_offset,
13600                ppc64_elf_howto_table[r_type]->name,
13601                sym_name);
13602         }
13603
13604       /* Ensure reloc mapping code below stays sane.  */
13605       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13606           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13607           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13608           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13609           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13610           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13611           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13612           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13613           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13614           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13615         abort ();
13616
13617       switch (r_type)
13618         {
13619         default:
13620           break;
13621
13622         case R_PPC64_LO_DS_OPT:
13623           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13624           if ((insn & (0x3f << 26)) != 58u << 26)
13625             abort ();
13626           insn += (14u << 26) - (58u << 26);
13627           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13628           r_type = R_PPC64_TOC16_LO;
13629           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13630           break;
13631
13632         case R_PPC64_TOC16:
13633         case R_PPC64_TOC16_LO:
13634         case R_PPC64_TOC16_DS:
13635         case R_PPC64_TOC16_LO_DS:
13636           {
13637             /* Check for toc tls entries.  */
13638             unsigned char *toc_tls;
13639             int retval;
13640
13641             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13642                                    &local_syms, rel, input_bfd);
13643             if (retval == 0)
13644               return FALSE;
13645
13646             if (toc_tls)
13647               {
13648                 tls_mask = *toc_tls;
13649                 if (r_type == R_PPC64_TOC16_DS
13650                     || r_type == R_PPC64_TOC16_LO_DS)
13651                   {
13652                     if (tls_mask != 0
13653                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13654                       goto toctprel;
13655                   }
13656                 else
13657                   {
13658                     /* If we found a GD reloc pair, then we might be
13659                        doing a GD->IE transition.  */
13660                     if (retval == 2)
13661                       {
13662                         tls_gd = TLS_TPRELGD;
13663                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13664                           goto tls_ldgd_opt;
13665                       }
13666                     else if (retval == 3)
13667                       {
13668                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13669                           goto tls_ldgd_opt;
13670                       }
13671                   }
13672               }
13673           }
13674           break;
13675
13676         case R_PPC64_GOT_TPREL16_HI:
13677         case R_PPC64_GOT_TPREL16_HA:
13678           if (tls_mask != 0
13679               && (tls_mask & TLS_TPREL) == 0)
13680             {
13681               rel->r_offset -= d_offset;
13682               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13683               r_type = R_PPC64_NONE;
13684               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13685             }
13686           break;
13687
13688         case R_PPC64_GOT_TPREL16_DS:
13689         case R_PPC64_GOT_TPREL16_LO_DS:
13690           if (tls_mask != 0
13691               && (tls_mask & TLS_TPREL) == 0)
13692             {
13693             toctprel:
13694               insn = bfd_get_32 (input_bfd,
13695                                  contents + rel->r_offset - d_offset);
13696               insn &= 31 << 21;
13697               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13698               bfd_put_32 (input_bfd, insn,
13699                           contents + rel->r_offset - d_offset);
13700               r_type = R_PPC64_TPREL16_HA;
13701               if (toc_symndx != 0)
13702                 {
13703                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13704                   rel->r_addend = toc_addend;
13705                   /* We changed the symbol.  Start over in order to
13706                      get h, sym, sec etc. right.  */
13707                   goto again;
13708                 }
13709               else
13710                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13711             }
13712           break;
13713
13714         case R_PPC64_TLS:
13715           if (tls_mask != 0
13716               && (tls_mask & TLS_TPREL) == 0)
13717             {
13718               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13719               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13720               if (insn == 0)
13721                 abort ();
13722               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13723               /* Was PPC64_TLS which sits on insn boundary, now
13724                  PPC64_TPREL16_LO which is at low-order half-word.  */
13725               rel->r_offset += d_offset;
13726               r_type = R_PPC64_TPREL16_LO;
13727               if (toc_symndx != 0)
13728                 {
13729                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13730                   rel->r_addend = toc_addend;
13731                   /* We changed the symbol.  Start over in order to
13732                      get h, sym, sec etc. right.  */
13733                   goto again;
13734                 }
13735               else
13736                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13737             }
13738           break;
13739
13740         case R_PPC64_GOT_TLSGD16_HI:
13741         case R_PPC64_GOT_TLSGD16_HA:
13742           tls_gd = TLS_TPRELGD;
13743           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13744             goto tls_gdld_hi;
13745           break;
13746
13747         case R_PPC64_GOT_TLSLD16_HI:
13748         case R_PPC64_GOT_TLSLD16_HA:
13749           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13750             {
13751             tls_gdld_hi:
13752               if ((tls_mask & tls_gd) != 0)
13753                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13754                           + R_PPC64_GOT_TPREL16_DS);
13755               else
13756                 {
13757                   rel->r_offset -= d_offset;
13758                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13759                   r_type = R_PPC64_NONE;
13760                 }
13761               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13762             }
13763           break;
13764
13765         case R_PPC64_GOT_TLSGD16:
13766         case R_PPC64_GOT_TLSGD16_LO:
13767           tls_gd = TLS_TPRELGD;
13768           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13769             goto tls_ldgd_opt;
13770           break;
13771
13772         case R_PPC64_GOT_TLSLD16:
13773         case R_PPC64_GOT_TLSLD16_LO:
13774           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13775             {
13776               unsigned int insn1, insn2;
13777               bfd_vma offset;
13778
13779             tls_ldgd_opt:
13780               offset = (bfd_vma) -1;
13781               /* If not using the newer R_PPC64_TLSGD/LD to mark
13782                  __tls_get_addr calls, we must trust that the call
13783                  stays with its arg setup insns, ie. that the next
13784                  reloc is the __tls_get_addr call associated with
13785                  the current reloc.  Edit both insns.  */
13786               if (input_section->has_tls_get_addr_call
13787                   && rel + 1 < relend
13788                   && branch_reloc_hash_match (input_bfd, rel + 1,
13789                                               htab->tls_get_addr,
13790                                               htab->tls_get_addr_fd))
13791                 offset = rel[1].r_offset;
13792               /* We read the low GOT_TLS (or TOC16) insn because we
13793                  need to keep the destination reg.  It may be
13794                  something other than the usual r3, and moved to r3
13795                  before the call by intervening code.  */
13796               insn1 = bfd_get_32 (input_bfd,
13797                                   contents + rel->r_offset - d_offset);
13798               if ((tls_mask & tls_gd) != 0)
13799                 {
13800                   /* IE */
13801                   insn1 &= (0x1f << 21) | (0x1f << 16);
13802                   insn1 |= 58 << 26;    /* ld */
13803                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13804                   if (offset != (bfd_vma) -1)
13805                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13806                   if ((tls_mask & TLS_EXPLICIT) == 0)
13807                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13808                               + R_PPC64_GOT_TPREL16_DS);
13809                   else
13810                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13811                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13812                 }
13813               else
13814                 {
13815                   /* LE */
13816                   insn1 &= 0x1f << 21;
13817                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13818                   insn2 = 0x38630000;   /* addi 3,3,0 */
13819                   if (tls_gd == 0)
13820                     {
13821                       /* Was an LD reloc.  */
13822                       if (toc_symndx)
13823                         sec = local_sections[toc_symndx];
13824                       for (r_symndx = 0;
13825                            r_symndx < symtab_hdr->sh_info;
13826                            r_symndx++)
13827                         if (local_sections[r_symndx] == sec)
13828                           break;
13829                       if (r_symndx >= symtab_hdr->sh_info)
13830                         r_symndx = STN_UNDEF;
13831                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13832                       if (r_symndx != STN_UNDEF)
13833                         rel->r_addend -= (local_syms[r_symndx].st_value
13834                                           + sec->output_offset
13835                                           + sec->output_section->vma);
13836                     }
13837                   else if (toc_symndx != 0)
13838                     {
13839                       r_symndx = toc_symndx;
13840                       rel->r_addend = toc_addend;
13841                     }
13842                   r_type = R_PPC64_TPREL16_HA;
13843                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13844                   if (offset != (bfd_vma) -1)
13845                     {
13846                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13847                                                     R_PPC64_TPREL16_LO);
13848                       rel[1].r_offset = offset + d_offset;
13849                       rel[1].r_addend = rel->r_addend;
13850                     }
13851                 }
13852               bfd_put_32 (input_bfd, insn1,
13853                           contents + rel->r_offset - d_offset);
13854               if (offset != (bfd_vma) -1)
13855                 bfd_put_32 (input_bfd, insn2, contents + offset);
13856               if ((tls_mask & tls_gd) == 0
13857                   && (tls_gd == 0 || toc_symndx != 0))
13858                 {
13859                   /* We changed the symbol.  Start over in order
13860                      to get h, sym, sec etc. right.  */
13861                   goto again;
13862                 }
13863             }
13864           break;
13865
13866         case R_PPC64_TLSGD:
13867           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13868             {
13869               unsigned int insn2;
13870               bfd_vma offset = rel->r_offset;
13871
13872               if ((tls_mask & TLS_TPRELGD) != 0)
13873                 {
13874                   /* IE */
13875                   r_type = R_PPC64_NONE;
13876                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13877                 }
13878               else
13879                 {
13880                   /* LE */
13881                   if (toc_symndx != 0)
13882                     {
13883                       r_symndx = toc_symndx;
13884                       rel->r_addend = toc_addend;
13885                     }
13886                   r_type = R_PPC64_TPREL16_LO;
13887                   rel->r_offset = offset + d_offset;
13888                   insn2 = 0x38630000;   /* addi 3,3,0 */
13889                 }
13890               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13891               /* Zap the reloc on the _tls_get_addr call too.  */
13892               BFD_ASSERT (offset == rel[1].r_offset);
13893               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13894               bfd_put_32 (input_bfd, insn2, contents + offset);
13895               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13896                 goto again;
13897             }
13898           break;
13899
13900         case R_PPC64_TLSLD:
13901           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13902             {
13903               unsigned int insn2;
13904               bfd_vma offset = rel->r_offset;
13905
13906               if (toc_symndx)
13907                 sec = local_sections[toc_symndx];
13908               for (r_symndx = 0;
13909                    r_symndx < symtab_hdr->sh_info;
13910                    r_symndx++)
13911                 if (local_sections[r_symndx] == sec)
13912                   break;
13913               if (r_symndx >= symtab_hdr->sh_info)
13914                 r_symndx = STN_UNDEF;
13915               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13916               if (r_symndx != STN_UNDEF)
13917                 rel->r_addend -= (local_syms[r_symndx].st_value
13918                                   + sec->output_offset
13919                                   + sec->output_section->vma);
13920
13921               r_type = R_PPC64_TPREL16_LO;
13922               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13923               rel->r_offset = offset + d_offset;
13924               /* Zap the reloc on the _tls_get_addr call too.  */
13925               BFD_ASSERT (offset == rel[1].r_offset);
13926               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13927               insn2 = 0x38630000;       /* addi 3,3,0 */
13928               bfd_put_32 (input_bfd, insn2, contents + offset);
13929               goto again;
13930             }
13931           break;
13932
13933         case R_PPC64_DTPMOD64:
13934           if (rel + 1 < relend
13935               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13936               && rel[1].r_offset == rel->r_offset + 8)
13937             {
13938               if ((tls_mask & TLS_GD) == 0)
13939                 {
13940                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13941                   if ((tls_mask & TLS_TPRELGD) != 0)
13942                     r_type = R_PPC64_TPREL64;
13943                   else
13944                     {
13945                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13946                       r_type = R_PPC64_NONE;
13947                     }
13948                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13949                 }
13950             }
13951           else
13952             {
13953               if ((tls_mask & TLS_LD) == 0)
13954                 {
13955                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13956                   r_type = R_PPC64_NONE;
13957                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13958                 }
13959             }
13960           break;
13961
13962         case R_PPC64_TPREL64:
13963           if ((tls_mask & TLS_TPREL) == 0)
13964             {
13965               r_type = R_PPC64_NONE;
13966               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13967             }
13968           break;
13969
13970         case R_PPC64_ENTRY:
13971           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13972           if (!bfd_link_pic (info)
13973               && !info->traditional_format
13974               && relocation + 0x80008000 <= 0xffffffff)
13975             {
13976               unsigned int insn1, insn2;
13977
13978               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13979               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13980               if ((insn1 & ~0xfffc) == LD_R2_0R12
13981                   && insn2 == ADD_R2_R2_R12)
13982                 {
13983                   bfd_put_32 (input_bfd,
13984                               LIS_R2 + PPC_HA (relocation),
13985                               contents + rel->r_offset);
13986                   bfd_put_32 (input_bfd,
13987                               ADDI_R2_R2 + PPC_LO (relocation),
13988                               contents + rel->r_offset + 4);
13989                 }
13990             }
13991           else
13992             {
13993               relocation -= (rel->r_offset
13994                              + input_section->output_offset
13995                              + input_section->output_section->vma);
13996               if (relocation + 0x80008000 <= 0xffffffff)
13997                 {
13998                   unsigned int insn1, insn2;
13999
14000                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14001                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14002                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14003                       && insn2 == ADD_R2_R2_R12)
14004                     {
14005                       bfd_put_32 (input_bfd,
14006                                   ADDIS_R2_R12 + PPC_HA (relocation),
14007                                   contents + rel->r_offset);
14008                       bfd_put_32 (input_bfd,
14009                                   ADDI_R2_R2 + PPC_LO (relocation),
14010                                   contents + rel->r_offset + 4);
14011                     }
14012                 }
14013             }
14014           break;
14015
14016         case R_PPC64_REL16_HA:
14017           /* If we are generating a non-PIC executable, edit
14018              .  0:      addis 2,12,.TOC.-0b@ha
14019              .          addi 2,2,.TOC.-0b@l
14020              used by ELFv2 global entry points to set up r2, to
14021              .          lis 2,.TOC.@ha
14022              .          addi 2,2,.TOC.@l
14023              if .TOC. is in range.  */
14024           if (!bfd_link_pic (info)
14025               && !info->traditional_format
14026               && !htab->opd_abi
14027               && rel->r_addend == d_offset
14028               && h != NULL && &h->elf == htab->elf.hgot
14029               && rel + 1 < relend
14030               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14031               && rel[1].r_offset == rel->r_offset + 4
14032               && rel[1].r_addend == rel->r_addend + 4
14033               && relocation + 0x80008000 <= 0xffffffff)
14034             {
14035               unsigned int insn1, insn2;
14036               bfd_vma offset = rel->r_offset - d_offset;
14037               insn1 = bfd_get_32 (input_bfd, contents + offset);
14038               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14039               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14040                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14041                 {
14042                   r_type = R_PPC64_ADDR16_HA;
14043                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14044                   rel->r_addend -= d_offset;
14045                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14046                   rel[1].r_addend -= d_offset + 4;
14047                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14048                 }
14049             }
14050           break;
14051         }
14052
14053       /* Handle other relocations that tweak non-addend part of insn.  */
14054       insn = 0;
14055       max_br_offset = 1 << 25;
14056       addend = rel->r_addend;
14057       reloc_dest = DEST_NORMAL;
14058       switch (r_type)
14059         {
14060         default:
14061           break;
14062
14063         case R_PPC64_TOCSAVE:
14064           if (relocation + addend == (rel->r_offset
14065                                       + input_section->output_offset
14066                                       + input_section->output_section->vma)
14067               && tocsave_find (htab, NO_INSERT,
14068                                &local_syms, rel, input_bfd))
14069             {
14070               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14071               if (insn == NOP
14072                   || insn == CROR_151515 || insn == CROR_313131)
14073                 bfd_put_32 (input_bfd,
14074                             STD_R2_0R1 + STK_TOC (htab),
14075                             contents + rel->r_offset);
14076             }
14077           break;
14078
14079           /* Branch taken prediction relocations.  */
14080         case R_PPC64_ADDR14_BRTAKEN:
14081         case R_PPC64_REL14_BRTAKEN:
14082           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14083           /* Fall through.  */
14084
14085           /* Branch not taken prediction relocations.  */
14086         case R_PPC64_ADDR14_BRNTAKEN:
14087         case R_PPC64_REL14_BRNTAKEN:
14088           insn |= bfd_get_32 (input_bfd,
14089                               contents + rel->r_offset) & ~(0x01 << 21);
14090           /* Fall through.  */
14091
14092         case R_PPC64_REL14:
14093           max_br_offset = 1 << 15;
14094           /* Fall through.  */
14095
14096         case R_PPC64_REL24:
14097           /* Calls to functions with a different TOC, such as calls to
14098              shared objects, need to alter the TOC pointer.  This is
14099              done using a linkage stub.  A REL24 branching to these
14100              linkage stubs needs to be followed by a nop, as the nop
14101              will be replaced with an instruction to restore the TOC
14102              base pointer.  */
14103           fdh = h;
14104           if (h != NULL
14105               && h->oh != NULL
14106               && h->oh->is_func_descriptor)
14107             fdh = ppc_follow_link (h->oh);
14108           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14109                                            htab);
14110           if (stub_entry != NULL
14111               && (stub_entry->stub_type == ppc_stub_plt_call
14112                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14113                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14114                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14115             {
14116               bfd_boolean can_plt_call = FALSE;
14117
14118               if (stub_entry->stub_type == ppc_stub_plt_call
14119                   && !htab->opd_abi
14120                   && htab->params->plt_localentry0 != 0
14121                   && is_elfv2_localentry0 (&h->elf))
14122                 {
14123                   /* The function doesn't use or change r2.  */
14124                   can_plt_call = TRUE;
14125                 }
14126
14127               /* All of these stubs may modify r2, so there must be a
14128                  branch and link followed by a nop.  The nop is
14129                  replaced by an insn to restore r2.  */
14130               else if (rel->r_offset + 8 <= input_section->size)
14131                 {
14132                   unsigned long br;
14133
14134                   br = bfd_get_32 (input_bfd,
14135                                    contents + rel->r_offset);
14136                   if ((br & 1) != 0)
14137                     {
14138                       unsigned long nop;
14139
14140                       nop = bfd_get_32 (input_bfd,
14141                                         contents + rel->r_offset + 4);
14142                       if (nop == NOP
14143                           || nop == CROR_151515 || nop == CROR_313131)
14144                         {
14145                           if (h != NULL
14146                               && (h == htab->tls_get_addr_fd
14147                                   || h == htab->tls_get_addr)
14148                               && htab->params->tls_get_addr_opt)
14149                             {
14150                               /* Special stub used, leave nop alone.  */
14151                             }
14152                           else
14153                             bfd_put_32 (input_bfd,
14154                                         LD_R2_0R1 + STK_TOC (htab),
14155                                         contents + rel->r_offset + 4);
14156                           can_plt_call = TRUE;
14157                         }
14158                     }
14159                 }
14160
14161               if (!can_plt_call && h != NULL)
14162                 {
14163                   const char *name = h->elf.root.root.string;
14164
14165                   if (*name == '.')
14166                     ++name;
14167
14168                   if (strncmp (name, "__libc_start_main", 17) == 0
14169                       && (name[17] == 0 || name[17] == '@'))
14170                     {
14171                       /* Allow crt1 branch to go via a toc adjusting
14172                          stub.  Other calls that never return could do
14173                          the same, if we could detect such.  */
14174                       can_plt_call = TRUE;
14175                     }
14176                 }
14177
14178               if (!can_plt_call)
14179                 {
14180                   /* g++ as of 20130507 emits self-calls without a
14181                      following nop.  This is arguably wrong since we
14182                      have conflicting information.  On the one hand a
14183                      global symbol and on the other a local call
14184                      sequence, but don't error for this special case.
14185                      It isn't possible to cheaply verify we have
14186                      exactly such a call.  Allow all calls to the same
14187                      section.  */
14188                   asection *code_sec = sec;
14189
14190                   if (get_opd_info (sec) != NULL)
14191                     {
14192                       bfd_vma off = (relocation + addend
14193                                      - sec->output_section->vma
14194                                      - sec->output_offset);
14195
14196                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14197                     }
14198                   if (code_sec == input_section)
14199                     can_plt_call = TRUE;
14200                 }
14201
14202               if (!can_plt_call)
14203                 {
14204                   if (stub_entry->stub_type == ppc_stub_plt_call
14205                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14206                     info->callbacks->einfo
14207                       /* xgettext:c-format */
14208                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14209                          "recompile with -fPIC\n"),
14210                        input_bfd, input_section, rel->r_offset, sym_name);
14211                   else
14212                     info->callbacks->einfo
14213                       /* xgettext:c-format */
14214                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14215                          "(-mcmodel=small toc adjust stub)\n"),
14216                        input_bfd, input_section, rel->r_offset, sym_name);
14217
14218                   bfd_set_error (bfd_error_bad_value);
14219                   ret = FALSE;
14220                 }
14221
14222               if (can_plt_call
14223                   && (stub_entry->stub_type == ppc_stub_plt_call
14224                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14225                 unresolved_reloc = FALSE;
14226             }
14227
14228           if ((stub_entry == NULL
14229                || stub_entry->stub_type == ppc_stub_long_branch
14230                || stub_entry->stub_type == ppc_stub_plt_branch)
14231               && get_opd_info (sec) != NULL)
14232             {
14233               /* The branch destination is the value of the opd entry. */
14234               bfd_vma off = (relocation + addend
14235                              - sec->output_section->vma
14236                              - sec->output_offset);
14237               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14238               if (dest != (bfd_vma) -1)
14239                 {
14240                   relocation = dest;
14241                   addend = 0;
14242                   reloc_dest = DEST_OPD;
14243                 }
14244             }
14245
14246           /* If the branch is out of reach we ought to have a long
14247              branch stub.  */
14248           from = (rel->r_offset
14249                   + input_section->output_offset
14250                   + input_section->output_section->vma);
14251
14252           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14253                                                   ? fdh->elf.other
14254                                                   : sym->st_other);
14255
14256           if (stub_entry != NULL
14257               && (stub_entry->stub_type == ppc_stub_long_branch
14258                   || stub_entry->stub_type == ppc_stub_plt_branch)
14259               && (r_type == R_PPC64_ADDR14_BRTAKEN
14260                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14261                   || (relocation + addend - from + max_br_offset
14262                       < 2 * max_br_offset)))
14263             /* Don't use the stub if this branch is in range.  */
14264             stub_entry = NULL;
14265
14266           if (stub_entry != NULL)
14267             {
14268               /* Munge up the value and addend so that we call the stub
14269                  rather than the procedure directly.  */
14270               asection *stub_sec = stub_entry->group->stub_sec;
14271
14272               if (stub_entry->stub_type == ppc_stub_save_res)
14273                 relocation += (stub_sec->output_offset
14274                                + stub_sec->output_section->vma
14275                                + stub_sec->size - htab->sfpr->size
14276                                - htab->sfpr->output_offset
14277                                - htab->sfpr->output_section->vma);
14278               else
14279                 relocation = (stub_entry->stub_offset
14280                               + stub_sec->output_offset
14281                               + stub_sec->output_section->vma);
14282               addend = 0;
14283               reloc_dest = DEST_STUB;
14284
14285               if ((stub_entry->stub_type == ppc_stub_plt_call
14286                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14287                   && (ALWAYS_EMIT_R2SAVE
14288                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14289                   && rel + 1 < relend
14290                   && rel[1].r_offset == rel->r_offset + 4
14291                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14292                 relocation += 4;
14293             }
14294
14295           if (insn != 0)
14296             {
14297               if (is_isa_v2)
14298                 {
14299                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14300                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14301                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14302                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14303                     insn |= 0x02 << 21;
14304                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14305                     insn |= 0x08 << 21;
14306                   else
14307                     break;
14308                 }
14309               else
14310                 {
14311                   /* Invert 'y' bit if not the default.  */
14312                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14313                     insn ^= 0x01 << 21;
14314                 }
14315
14316               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14317             }
14318
14319           /* NOP out calls to undefined weak functions.
14320              We can thus call a weak function without first
14321              checking whether the function is defined.  */
14322           else if (h != NULL
14323                    && h->elf.root.type == bfd_link_hash_undefweak
14324                    && h->elf.dynindx == -1
14325                    && r_type == R_PPC64_REL24
14326                    && relocation == 0
14327                    && addend == 0)
14328             {
14329               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14330               goto copy_reloc;
14331             }
14332           break;
14333         }
14334
14335       /* Set `addend'.  */
14336       tls_type = 0;
14337       switch (r_type)
14338         {
14339         default:
14340           info->callbacks->einfo
14341             /* xgettext:c-format */
14342             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14343              input_bfd, (int) r_type, sym_name);
14344
14345           bfd_set_error (bfd_error_bad_value);
14346           ret = FALSE;
14347           goto copy_reloc;
14348
14349         case R_PPC64_NONE:
14350         case R_PPC64_TLS:
14351         case R_PPC64_TLSGD:
14352         case R_PPC64_TLSLD:
14353         case R_PPC64_TOCSAVE:
14354         case R_PPC64_GNU_VTINHERIT:
14355         case R_PPC64_GNU_VTENTRY:
14356         case R_PPC64_ENTRY:
14357           goto copy_reloc;
14358
14359           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14360              address in the GOT as relocation value instead of the
14361              symbol's value itself.  Also, create a GOT entry for the
14362              symbol and put the symbol value there.  */
14363         case R_PPC64_GOT_TLSGD16:
14364         case R_PPC64_GOT_TLSGD16_LO:
14365         case R_PPC64_GOT_TLSGD16_HI:
14366         case R_PPC64_GOT_TLSGD16_HA:
14367           tls_type = TLS_TLS | TLS_GD;
14368           goto dogot;
14369
14370         case R_PPC64_GOT_TLSLD16:
14371         case R_PPC64_GOT_TLSLD16_LO:
14372         case R_PPC64_GOT_TLSLD16_HI:
14373         case R_PPC64_GOT_TLSLD16_HA:
14374           tls_type = TLS_TLS | TLS_LD;
14375           goto dogot;
14376
14377         case R_PPC64_GOT_TPREL16_DS:
14378         case R_PPC64_GOT_TPREL16_LO_DS:
14379         case R_PPC64_GOT_TPREL16_HI:
14380         case R_PPC64_GOT_TPREL16_HA:
14381           tls_type = TLS_TLS | TLS_TPREL;
14382           goto dogot;
14383
14384         case R_PPC64_GOT_DTPREL16_DS:
14385         case R_PPC64_GOT_DTPREL16_LO_DS:
14386         case R_PPC64_GOT_DTPREL16_HI:
14387         case R_PPC64_GOT_DTPREL16_HA:
14388           tls_type = TLS_TLS | TLS_DTPREL;
14389           goto dogot;
14390
14391         case R_PPC64_GOT16:
14392         case R_PPC64_GOT16_LO:
14393         case R_PPC64_GOT16_HI:
14394         case R_PPC64_GOT16_HA:
14395         case R_PPC64_GOT16_DS:
14396         case R_PPC64_GOT16_LO_DS:
14397         dogot:
14398           {
14399             /* Relocation is to the entry for this symbol in the global
14400                offset table.  */
14401             asection *got;
14402             bfd_vma *offp;
14403             bfd_vma off;
14404             unsigned long indx = 0;
14405             struct got_entry *ent;
14406
14407             if (tls_type == (TLS_TLS | TLS_LD)
14408                 && (h == NULL
14409                     || !h->elf.def_dynamic))
14410               ent = ppc64_tlsld_got (input_bfd);
14411             else
14412               {
14413                 if (h != NULL)
14414                   {
14415                     if (!htab->elf.dynamic_sections_created
14416                         || h->elf.dynindx == -1
14417                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14418                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14419                       /* This is actually a static link, or it is a
14420                          -Bsymbolic link and the symbol is defined
14421                          locally, or the symbol was forced to be local
14422                          because of a version file.  */
14423                       ;
14424                     else
14425                       {
14426                         indx = h->elf.dynindx;
14427                         unresolved_reloc = FALSE;
14428                       }
14429                     ent = h->elf.got.glist;
14430                   }
14431                 else
14432                   {
14433                     if (local_got_ents == NULL)
14434                       abort ();
14435                     ent = local_got_ents[r_symndx];
14436                   }
14437
14438                 for (; ent != NULL; ent = ent->next)
14439                   if (ent->addend == orig_rel.r_addend
14440                       && ent->owner == input_bfd
14441                       && ent->tls_type == tls_type)
14442                     break;
14443               }
14444
14445             if (ent == NULL)
14446               abort ();
14447             if (ent->is_indirect)
14448               ent = ent->got.ent;
14449             offp = &ent->got.offset;
14450             got = ppc64_elf_tdata (ent->owner)->got;
14451             if (got == NULL)
14452               abort ();
14453
14454             /* The offset must always be a multiple of 8.  We use the
14455                least significant bit to record whether we have already
14456                processed this entry.  */
14457             off = *offp;
14458             if ((off & 1) != 0)
14459               off &= ~1;
14460             else
14461               {
14462                 /* Generate relocs for the dynamic linker, except in
14463                    the case of TLSLD where we'll use one entry per
14464                    module.  */
14465                 asection *relgot;
14466                 bfd_boolean ifunc;
14467
14468                 *offp = off | 1;
14469                 relgot = NULL;
14470                 ifunc = (h != NULL
14471                          ? h->elf.type == STT_GNU_IFUNC
14472                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14473                 if (ifunc)
14474                   {
14475                     relgot = htab->elf.irelplt;
14476                     if (indx == 0)
14477                       htab->local_ifunc_resolver = 1;
14478                     else if (is_static_defined (&h->elf))
14479                       htab->maybe_local_ifunc_resolver = 1;
14480                   }
14481                 else if (indx != 0
14482                          || (bfd_link_pic (info)
14483                              && (h == NULL
14484                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14485                                  || (tls_type == (TLS_TLS | TLS_LD)
14486                                      && !h->elf.def_dynamic))
14487                              && !(tls_type == (TLS_TLS | TLS_TPREL)
14488                                   && bfd_link_executable (info)
14489                                   && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14490                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14491                 if (relgot != NULL)
14492                   {
14493                     outrel.r_offset = (got->output_section->vma
14494                                        + got->output_offset
14495                                        + off);
14496                     outrel.r_addend = addend;
14497                     if (tls_type & (TLS_LD | TLS_GD))
14498                       {
14499                         outrel.r_addend = 0;
14500                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14501                         if (tls_type == (TLS_TLS | TLS_GD))
14502                           {
14503                             loc = relgot->contents;
14504                             loc += (relgot->reloc_count++
14505                                     * sizeof (Elf64_External_Rela));
14506                             bfd_elf64_swap_reloca_out (output_bfd,
14507                                                        &outrel, loc);
14508                             outrel.r_offset += 8;
14509                             outrel.r_addend = addend;
14510                             outrel.r_info
14511                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14512                           }
14513                       }
14514                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14515                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14516                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14517                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14518                     else if (indx != 0)
14519                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14520                     else
14521                       {
14522                         if (ifunc)
14523                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14524                         else
14525                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14526
14527                         /* Write the .got section contents for the sake
14528                            of prelink.  */
14529                         loc = got->contents + off;
14530                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14531                                     loc);
14532                       }
14533
14534                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14535                       {
14536                         outrel.r_addend += relocation;
14537                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14538                           {
14539                             if (htab->elf.tls_sec == NULL)
14540                               outrel.r_addend = 0;
14541                             else
14542                               outrel.r_addend -= htab->elf.tls_sec->vma;
14543                           }
14544                       }
14545                     loc = relgot->contents;
14546                     loc += (relgot->reloc_count++
14547                             * sizeof (Elf64_External_Rela));
14548                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14549                   }
14550
14551                 /* Init the .got section contents here if we're not
14552                    emitting a reloc.  */
14553                 else
14554                   {
14555                     relocation += addend;
14556                     if (tls_type != 0)
14557                       {
14558                         if (htab->elf.tls_sec == NULL)
14559                           relocation = 0;
14560                         else
14561                           {
14562                             if (tls_type & TLS_LD)
14563                               relocation = 0;
14564                             else
14565                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14566                             if (tls_type & TLS_TPREL)
14567                               relocation += DTP_OFFSET - TP_OFFSET;
14568                           }
14569
14570                         if (tls_type & (TLS_GD | TLS_LD))
14571                           {
14572                             bfd_put_64 (output_bfd, relocation,
14573                                         got->contents + off + 8);
14574                             relocation = 1;
14575                           }
14576                       }
14577                     bfd_put_64 (output_bfd, relocation,
14578                                 got->contents + off);
14579                   }
14580               }
14581
14582             if (off >= (bfd_vma) -2)
14583               abort ();
14584
14585             relocation = got->output_section->vma + got->output_offset + off;
14586             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14587           }
14588           break;
14589
14590         case R_PPC64_PLT16_HA:
14591         case R_PPC64_PLT16_HI:
14592         case R_PPC64_PLT16_LO:
14593         case R_PPC64_PLT32:
14594         case R_PPC64_PLT64:
14595           /* Relocation is to the entry for this symbol in the
14596              procedure linkage table.  */
14597           {
14598             struct plt_entry **plt_list = NULL;
14599             if (h != NULL)
14600               plt_list = &h->elf.plt.plist;
14601             else if (local_got_ents != NULL)
14602               {
14603                 struct plt_entry **local_plt = (struct plt_entry **)
14604                   (local_got_ents + symtab_hdr->sh_info);
14605                 unsigned char *local_got_tls_masks = (unsigned char *)
14606                   (local_plt + symtab_hdr->sh_info);
14607                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14608                   plt_list = local_plt + r_symndx;
14609               }
14610             if (plt_list)
14611               {
14612                 struct plt_entry *ent;
14613
14614                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14615                   if (ent->plt.offset != (bfd_vma) -1
14616                       && ent->addend == orig_rel.r_addend)
14617                     {
14618                       asection *plt;
14619
14620                       plt = htab->elf.splt;
14621                       if (!htab->elf.dynamic_sections_created
14622                           || h == NULL
14623                           || h->elf.dynindx == -1)
14624                         plt = htab->elf.iplt;
14625                       relocation = (plt->output_section->vma
14626                                     + plt->output_offset
14627                                     + ent->plt.offset);
14628                       addend = 0;
14629                       unresolved_reloc = FALSE;
14630                       break;
14631                     }
14632               }
14633           }
14634           break;
14635
14636         case R_PPC64_TOC:
14637           /* Relocation value is TOC base.  */
14638           relocation = TOCstart;
14639           if (r_symndx == STN_UNDEF)
14640             relocation += htab->sec_info[input_section->id].toc_off;
14641           else if (unresolved_reloc)
14642             ;
14643           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14644             relocation += htab->sec_info[sec->id].toc_off;
14645           else
14646             unresolved_reloc = TRUE;
14647           goto dodyn;
14648
14649           /* TOC16 relocs.  We want the offset relative to the TOC base,
14650              which is the address of the start of the TOC plus 0x8000.
14651              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14652              in this order.  */
14653         case R_PPC64_TOC16:
14654         case R_PPC64_TOC16_LO:
14655         case R_PPC64_TOC16_HI:
14656         case R_PPC64_TOC16_DS:
14657         case R_PPC64_TOC16_LO_DS:
14658         case R_PPC64_TOC16_HA:
14659           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14660           break;
14661
14662           /* Relocate against the beginning of the section.  */
14663         case R_PPC64_SECTOFF:
14664         case R_PPC64_SECTOFF_LO:
14665         case R_PPC64_SECTOFF_HI:
14666         case R_PPC64_SECTOFF_DS:
14667         case R_PPC64_SECTOFF_LO_DS:
14668         case R_PPC64_SECTOFF_HA:
14669           if (sec != NULL)
14670             addend -= sec->output_section->vma;
14671           break;
14672
14673         case R_PPC64_REL16:
14674         case R_PPC64_REL16_LO:
14675         case R_PPC64_REL16_HI:
14676         case R_PPC64_REL16_HA:
14677         case R_PPC64_REL16DX_HA:
14678           break;
14679
14680         case R_PPC64_REL14:
14681         case R_PPC64_REL14_BRNTAKEN:
14682         case R_PPC64_REL14_BRTAKEN:
14683         case R_PPC64_REL24:
14684           break;
14685
14686         case R_PPC64_TPREL16:
14687         case R_PPC64_TPREL16_LO:
14688         case R_PPC64_TPREL16_HI:
14689         case R_PPC64_TPREL16_HA:
14690         case R_PPC64_TPREL16_DS:
14691         case R_PPC64_TPREL16_LO_DS:
14692         case R_PPC64_TPREL16_HIGH:
14693         case R_PPC64_TPREL16_HIGHA:
14694         case R_PPC64_TPREL16_HIGHER:
14695         case R_PPC64_TPREL16_HIGHERA:
14696         case R_PPC64_TPREL16_HIGHEST:
14697         case R_PPC64_TPREL16_HIGHESTA:
14698           if (h != NULL
14699               && h->elf.root.type == bfd_link_hash_undefweak
14700               && h->elf.dynindx == -1)
14701             {
14702               /* Make this relocation against an undefined weak symbol
14703                  resolve to zero.  This is really just a tweak, since
14704                  code using weak externs ought to check that they are
14705                  defined before using them.  */
14706               bfd_byte *p = contents + rel->r_offset - d_offset;
14707
14708               insn = bfd_get_32 (input_bfd, p);
14709               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14710               if (insn != 0)
14711                 bfd_put_32 (input_bfd, insn, p);
14712               break;
14713             }
14714           if (htab->elf.tls_sec != NULL)
14715             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14716           /* The TPREL16 relocs shouldn't really be used in shared
14717              libs or with non-local symbols as that will result in
14718              DT_TEXTREL being set, but support them anyway.  */
14719           goto dodyn;
14720
14721         case R_PPC64_DTPREL16:
14722         case R_PPC64_DTPREL16_LO:
14723         case R_PPC64_DTPREL16_HI:
14724         case R_PPC64_DTPREL16_HA:
14725         case R_PPC64_DTPREL16_DS:
14726         case R_PPC64_DTPREL16_LO_DS:
14727         case R_PPC64_DTPREL16_HIGH:
14728         case R_PPC64_DTPREL16_HIGHA:
14729         case R_PPC64_DTPREL16_HIGHER:
14730         case R_PPC64_DTPREL16_HIGHERA:
14731         case R_PPC64_DTPREL16_HIGHEST:
14732         case R_PPC64_DTPREL16_HIGHESTA:
14733           if (htab->elf.tls_sec != NULL)
14734             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14735           break;
14736
14737         case R_PPC64_ADDR64_LOCAL:
14738           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14739                                               ? h->elf.other
14740                                               : sym->st_other);
14741           break;
14742
14743         case R_PPC64_DTPMOD64:
14744           relocation = 1;
14745           addend = 0;
14746           goto dodyn;
14747
14748         case R_PPC64_TPREL64:
14749           if (htab->elf.tls_sec != NULL)
14750             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14751           goto dodyn;
14752
14753         case R_PPC64_DTPREL64:
14754           if (htab->elf.tls_sec != NULL)
14755             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14756           /* Fall through.  */
14757
14758           /* Relocations that may need to be propagated if this is a
14759              dynamic object.  */
14760         case R_PPC64_REL30:
14761         case R_PPC64_REL32:
14762         case R_PPC64_REL64:
14763         case R_PPC64_ADDR14:
14764         case R_PPC64_ADDR14_BRNTAKEN:
14765         case R_PPC64_ADDR14_BRTAKEN:
14766         case R_PPC64_ADDR16:
14767         case R_PPC64_ADDR16_DS:
14768         case R_PPC64_ADDR16_HA:
14769         case R_PPC64_ADDR16_HI:
14770         case R_PPC64_ADDR16_HIGH:
14771         case R_PPC64_ADDR16_HIGHA:
14772         case R_PPC64_ADDR16_HIGHER:
14773         case R_PPC64_ADDR16_HIGHERA:
14774         case R_PPC64_ADDR16_HIGHEST:
14775         case R_PPC64_ADDR16_HIGHESTA:
14776         case R_PPC64_ADDR16_LO:
14777         case R_PPC64_ADDR16_LO_DS:
14778         case R_PPC64_ADDR24:
14779         case R_PPC64_ADDR32:
14780         case R_PPC64_ADDR64:
14781         case R_PPC64_UADDR16:
14782         case R_PPC64_UADDR32:
14783         case R_PPC64_UADDR64:
14784         dodyn:
14785           if ((input_section->flags & SEC_ALLOC) == 0)
14786             break;
14787
14788           if (NO_OPD_RELOCS && is_opd)
14789             break;
14790
14791           if (bfd_link_pic (info)
14792               ? ((h == NULL
14793                   || h->dyn_relocs != NULL)
14794                  && ((h != NULL && pc_dynrelocs (h))
14795                      || must_be_dyn_reloc (info, r_type)))
14796               : (h != NULL
14797                  ? h->dyn_relocs != NULL
14798                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14799             {
14800               bfd_boolean skip, relocate;
14801               asection *sreloc;
14802               bfd_vma out_off;
14803               long indx = 0;
14804
14805               /* When generating a dynamic object, these relocations
14806                  are copied into the output file to be resolved at run
14807                  time.  */
14808
14809               skip = FALSE;
14810               relocate = FALSE;
14811
14812               out_off = _bfd_elf_section_offset (output_bfd, info,
14813                                                  input_section, rel->r_offset);
14814               if (out_off == (bfd_vma) -1)
14815                 skip = TRUE;
14816               else if (out_off == (bfd_vma) -2)
14817                 skip = TRUE, relocate = TRUE;
14818               out_off += (input_section->output_section->vma
14819                           + input_section->output_offset);
14820               outrel.r_offset = out_off;
14821               outrel.r_addend = rel->r_addend;
14822
14823               /* Optimize unaligned reloc use.  */
14824               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14825                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14826                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14827               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14828                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14829                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14830               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14831                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14832                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14833
14834               if (skip)
14835                 memset (&outrel, 0, sizeof outrel);
14836               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14837                        && !is_opd
14838                        && r_type != R_PPC64_TOC)
14839                 {
14840                   indx = h->elf.dynindx;
14841                   BFD_ASSERT (indx != -1);
14842                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14843                 }
14844               else
14845                 {
14846                   /* This symbol is local, or marked to become local,
14847                      or this is an opd section reloc which must point
14848                      at a local function.  */
14849                   outrel.r_addend += relocation;
14850                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14851                     {
14852                       if (is_opd && h != NULL)
14853                         {
14854                           /* Lie about opd entries.  This case occurs
14855                              when building shared libraries and we
14856                              reference a function in another shared
14857                              lib.  The same thing happens for a weak
14858                              definition in an application that's
14859                              overridden by a strong definition in a
14860                              shared lib.  (I believe this is a generic
14861                              bug in binutils handling of weak syms.)
14862                              In these cases we won't use the opd
14863                              entry in this lib.  */
14864                           unresolved_reloc = FALSE;
14865                         }
14866                       if (!is_opd
14867                           && r_type == R_PPC64_ADDR64
14868                           && (h != NULL
14869                               ? h->elf.type == STT_GNU_IFUNC
14870                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14871                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14872                       else
14873                         {
14874                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14875
14876                           /* We need to relocate .opd contents for ld.so.
14877                              Prelink also wants simple and consistent rules
14878                              for relocs.  This make all RELATIVE relocs have
14879                              *r_offset equal to r_addend.  */
14880                           relocate = TRUE;
14881                         }
14882                     }
14883                   else
14884                     {
14885                       if (h != NULL
14886                           ? h->elf.type == STT_GNU_IFUNC
14887                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14888                         {
14889                           info->callbacks->einfo
14890                             /* xgettext:c-format */
14891                             (_("%H: %s for indirect "
14892                                "function `%T' unsupported\n"),
14893                              input_bfd, input_section, rel->r_offset,
14894                              ppc64_elf_howto_table[r_type]->name,
14895                              sym_name);
14896                           ret = FALSE;
14897                         }
14898                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14899                         ;
14900                       else if (sec == NULL || sec->owner == NULL)
14901                         {
14902                           bfd_set_error (bfd_error_bad_value);
14903                           return FALSE;
14904                         }
14905                       else
14906                         {
14907                           asection *osec;
14908
14909                           osec = sec->output_section;
14910                           indx = elf_section_data (osec)->dynindx;
14911
14912                           if (indx == 0)
14913                             {
14914                               if ((osec->flags & SEC_READONLY) == 0
14915                                   && htab->elf.data_index_section != NULL)
14916                                 osec = htab->elf.data_index_section;
14917                               else
14918                                 osec = htab->elf.text_index_section;
14919                               indx = elf_section_data (osec)->dynindx;
14920                             }
14921                           BFD_ASSERT (indx != 0);
14922
14923                           /* We are turning this relocation into one
14924                              against a section symbol, so subtract out
14925                              the output section's address but not the
14926                              offset of the input section in the output
14927                              section.  */
14928                           outrel.r_addend -= osec->vma;
14929                         }
14930
14931                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14932                     }
14933                 }
14934
14935               sreloc = elf_section_data (input_section)->sreloc;
14936               if (h != NULL
14937                   ? h->elf.type == STT_GNU_IFUNC
14938                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14939                 {
14940                   sreloc = htab->elf.irelplt;
14941                   if (indx == 0)
14942                     htab->local_ifunc_resolver = 1;
14943                   else if (is_static_defined (&h->elf))
14944                     htab->maybe_local_ifunc_resolver = 1;
14945                 }
14946               if (sreloc == NULL)
14947                 abort ();
14948
14949               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14950                   >= sreloc->size)
14951                 abort ();
14952               loc = sreloc->contents;
14953               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14954               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14955
14956               /* If this reloc is against an external symbol, it will
14957                  be computed at runtime, so there's no need to do
14958                  anything now.  However, for the sake of prelink ensure
14959                  that the section contents are a known value.  */
14960               if (! relocate)
14961                 {
14962                   unresolved_reloc = FALSE;
14963                   /* The value chosen here is quite arbitrary as ld.so
14964                      ignores section contents except for the special
14965                      case of .opd where the contents might be accessed
14966                      before relocation.  Choose zero, as that won't
14967                      cause reloc overflow.  */
14968                   relocation = 0;
14969                   addend = 0;
14970                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14971                      to improve backward compatibility with older
14972                      versions of ld.  */
14973                   if (r_type == R_PPC64_ADDR64)
14974                     addend = outrel.r_addend;
14975                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14976                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14977                     addend = outrel.r_offset;
14978                 }
14979             }
14980           break;
14981
14982         case R_PPC64_COPY:
14983         case R_PPC64_GLOB_DAT:
14984         case R_PPC64_JMP_SLOT:
14985         case R_PPC64_JMP_IREL:
14986         case R_PPC64_RELATIVE:
14987           /* We shouldn't ever see these dynamic relocs in relocatable
14988              files.  */
14989           /* Fall through.  */
14990
14991         case R_PPC64_PLTGOT16:
14992         case R_PPC64_PLTGOT16_DS:
14993         case R_PPC64_PLTGOT16_HA:
14994         case R_PPC64_PLTGOT16_HI:
14995         case R_PPC64_PLTGOT16_LO:
14996         case R_PPC64_PLTGOT16_LO_DS:
14997         case R_PPC64_PLTREL32:
14998         case R_PPC64_PLTREL64:
14999           /* These ones haven't been implemented yet.  */
15000
15001           info->callbacks->einfo
15002             /* xgettext:c-format */
15003             (_("%P: %B: %s is not supported for `%T'\n"),
15004              input_bfd,
15005              ppc64_elf_howto_table[r_type]->name, sym_name);
15006
15007           bfd_set_error (bfd_error_invalid_operation);
15008           ret = FALSE;
15009           goto copy_reloc;
15010         }
15011
15012       /* Multi-instruction sequences that access the TOC can be
15013          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15014          to             nop;           addi rb,r2,x;  */
15015       howto = ppc64_elf_howto_table[(int) r_type];
15016       switch (r_type)
15017         {
15018         default:
15019           break;
15020
15021         case R_PPC64_GOT_TLSLD16_HI:
15022         case R_PPC64_GOT_TLSGD16_HI:
15023         case R_PPC64_GOT_TPREL16_HI:
15024         case R_PPC64_GOT_DTPREL16_HI:
15025         case R_PPC64_GOT16_HI:
15026         case R_PPC64_TOC16_HI:
15027           /* These relocs would only be useful if building up an
15028              offset to later add to r2, perhaps in an indexed
15029              addressing mode instruction.  Don't try to optimize.
15030              Unfortunately, the possibility of someone building up an
15031              offset like this or even with the HA relocs, means that
15032              we need to check the high insn when optimizing the low
15033              insn.  */
15034           break;
15035
15036         case R_PPC64_GOT_TLSLD16_HA:
15037         case R_PPC64_GOT_TLSGD16_HA:
15038         case R_PPC64_GOT_TPREL16_HA:
15039         case R_PPC64_GOT_DTPREL16_HA:
15040         case R_PPC64_GOT16_HA:
15041         case R_PPC64_TOC16_HA:
15042           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15043               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15044             {
15045               bfd_byte *p = contents + (rel->r_offset & ~3);
15046               bfd_put_32 (input_bfd, NOP, p);
15047             }
15048           break;
15049
15050         case R_PPC64_GOT_TLSLD16_LO:
15051         case R_PPC64_GOT_TLSGD16_LO:
15052         case R_PPC64_GOT_TPREL16_LO_DS:
15053         case R_PPC64_GOT_DTPREL16_LO_DS:
15054         case R_PPC64_GOT16_LO:
15055         case R_PPC64_GOT16_LO_DS:
15056         case R_PPC64_TOC16_LO:
15057         case R_PPC64_TOC16_LO_DS:
15058           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15059               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15060             {
15061               bfd_byte *p = contents + (rel->r_offset & ~3);
15062               insn = bfd_get_32 (input_bfd, p);
15063               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15064                 {
15065                   /* Transform addic to addi when we change reg.  */
15066                   insn &= ~((0x3f << 26) | (0x1f << 16));
15067                   insn |= (14u << 26) | (2 << 16);
15068                 }
15069               else
15070                 {
15071                   insn &= ~(0x1f << 16);
15072                   insn |= 2 << 16;
15073                 }
15074               bfd_put_32 (input_bfd, insn, p);
15075             }
15076           break;
15077
15078         case R_PPC64_TPREL16_HA:
15079           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15080             {
15081               bfd_byte *p = contents + (rel->r_offset & ~3);
15082               insn = bfd_get_32 (input_bfd, p);
15083               if ((insn & ((0x3f << 26) | 0x1f << 16))
15084                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15085                 /* xgettext:c-format */
15086                 info->callbacks->minfo
15087                   (_("%H: warning: %s unexpected insn %#x.\n"),
15088                    input_bfd, input_section, rel->r_offset, howto->name, insn);
15089               else
15090                 bfd_put_32 (input_bfd, NOP, p);
15091             }
15092           break;
15093
15094         case R_PPC64_TPREL16_LO:
15095         case R_PPC64_TPREL16_LO_DS:
15096           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15097             {
15098               bfd_byte *p = contents + (rel->r_offset & ~3);
15099               insn = bfd_get_32 (input_bfd, p);
15100               insn &= ~(0x1f << 16);
15101               insn |= 13 << 16;
15102               bfd_put_32 (input_bfd, insn, p);
15103             }
15104           break;
15105         }
15106
15107       /* Do any further special processing.  */
15108       switch (r_type)
15109         {
15110         default:
15111           break;
15112
15113         case R_PPC64_REL16_HA:
15114         case R_PPC64_REL16DX_HA:
15115         case R_PPC64_ADDR16_HA:
15116         case R_PPC64_ADDR16_HIGHA:
15117         case R_PPC64_ADDR16_HIGHERA:
15118         case R_PPC64_ADDR16_HIGHESTA:
15119         case R_PPC64_TOC16_HA:
15120         case R_PPC64_SECTOFF_HA:
15121         case R_PPC64_TPREL16_HA:
15122         case R_PPC64_TPREL16_HIGHA:
15123         case R_PPC64_TPREL16_HIGHERA:
15124         case R_PPC64_TPREL16_HIGHESTA:
15125         case R_PPC64_DTPREL16_HA:
15126         case R_PPC64_DTPREL16_HIGHA:
15127         case R_PPC64_DTPREL16_HIGHERA:
15128         case R_PPC64_DTPREL16_HIGHESTA:
15129           /* It's just possible that this symbol is a weak symbol
15130              that's not actually defined anywhere. In that case,
15131              'sec' would be NULL, and we should leave the symbol
15132              alone (it will be set to zero elsewhere in the link).  */
15133           if (sec == NULL)
15134             break;
15135           /* Fall through.  */
15136
15137         case R_PPC64_GOT16_HA:
15138         case R_PPC64_PLTGOT16_HA:
15139         case R_PPC64_PLT16_HA:
15140         case R_PPC64_GOT_TLSGD16_HA:
15141         case R_PPC64_GOT_TLSLD16_HA:
15142         case R_PPC64_GOT_TPREL16_HA:
15143         case R_PPC64_GOT_DTPREL16_HA:
15144           /* Add 0x10000 if sign bit in 0:15 is set.
15145              Bits 0:15 are not used.  */
15146           addend += 0x8000;
15147           break;
15148
15149         case R_PPC64_ADDR16_DS:
15150         case R_PPC64_ADDR16_LO_DS:
15151         case R_PPC64_GOT16_DS:
15152         case R_PPC64_GOT16_LO_DS:
15153         case R_PPC64_PLT16_LO_DS:
15154         case R_PPC64_SECTOFF_DS:
15155         case R_PPC64_SECTOFF_LO_DS:
15156         case R_PPC64_TOC16_DS:
15157         case R_PPC64_TOC16_LO_DS:
15158         case R_PPC64_PLTGOT16_DS:
15159         case R_PPC64_PLTGOT16_LO_DS:
15160         case R_PPC64_GOT_TPREL16_DS:
15161         case R_PPC64_GOT_TPREL16_LO_DS:
15162         case R_PPC64_GOT_DTPREL16_DS:
15163         case R_PPC64_GOT_DTPREL16_LO_DS:
15164         case R_PPC64_TPREL16_DS:
15165         case R_PPC64_TPREL16_LO_DS:
15166         case R_PPC64_DTPREL16_DS:
15167         case R_PPC64_DTPREL16_LO_DS:
15168           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15169           mask = 3;
15170           /* If this reloc is against an lq, lxv, or stxv insn, then
15171              the value must be a multiple of 16.  This is somewhat of
15172              a hack, but the "correct" way to do this by defining _DQ
15173              forms of all the _DS relocs bloats all reloc switches in
15174              this file.  It doesn't make much sense to use these
15175              relocs in data, so testing the insn should be safe.  */
15176           if ((insn & (0x3f << 26)) == (56u << 26)
15177               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15178             mask = 15;
15179           relocation += addend;
15180           addend = insn & (mask ^ 3);
15181           if ((relocation & mask) != 0)
15182             {
15183               relocation ^= relocation & mask;
15184               info->callbacks->einfo
15185                 /* xgettext:c-format */
15186                 (_("%H: error: %s not a multiple of %u\n"),
15187                  input_bfd, input_section, rel->r_offset,
15188                  howto->name,
15189                  mask + 1);
15190               bfd_set_error (bfd_error_bad_value);
15191               ret = FALSE;
15192               goto copy_reloc;
15193             }
15194           break;
15195         }
15196
15197       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15198          because such sections are not SEC_ALLOC and thus ld.so will
15199          not process them.  */
15200       if (unresolved_reloc
15201           && !((input_section->flags & SEC_DEBUGGING) != 0
15202                && h->elf.def_dynamic)
15203           && _bfd_elf_section_offset (output_bfd, info, input_section,
15204                                       rel->r_offset) != (bfd_vma) -1)
15205         {
15206           info->callbacks->einfo
15207             /* xgettext:c-format */
15208             (_("%H: unresolvable %s against `%T'\n"),
15209              input_bfd, input_section, rel->r_offset,
15210              howto->name,
15211              h->elf.root.root.string);
15212           ret = FALSE;
15213         }
15214
15215       /* 16-bit fields in insns mostly have signed values, but a
15216          few insns have 16-bit unsigned values.  Really, we should
15217          have different reloc types.  */
15218       if (howto->complain_on_overflow != complain_overflow_dont
15219           && howto->dst_mask == 0xffff
15220           && (input_section->flags & SEC_CODE) != 0)
15221         {
15222           enum complain_overflow complain = complain_overflow_signed;
15223
15224           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15225           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15226             complain = complain_overflow_bitfield;
15227           else if (howto->rightshift == 0
15228                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15229                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15230                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15231                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15232                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15233                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15234             complain = complain_overflow_unsigned;
15235           if (howto->complain_on_overflow != complain)
15236             {
15237               alt_howto = *howto;
15238               alt_howto.complain_on_overflow = complain;
15239               howto = &alt_howto;
15240             }
15241         }
15242
15243       if (r_type == R_PPC64_REL16DX_HA)
15244         {
15245           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15246           if (rel->r_offset + 4 > input_section->size)
15247             r = bfd_reloc_outofrange;
15248           else
15249             {
15250               relocation += addend;
15251               relocation -= (rel->r_offset
15252                              + input_section->output_offset
15253                              + input_section->output_section->vma);
15254               relocation = (bfd_signed_vma) relocation >> 16;
15255               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15256               insn &= ~0x1fffc1;
15257               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15258               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15259               r = bfd_reloc_ok;
15260               if (relocation + 0x8000 > 0xffff)
15261                 r = bfd_reloc_overflow;
15262             }
15263         }
15264       else
15265         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15266                                       rel->r_offset, relocation, addend);
15267
15268       if (r != bfd_reloc_ok)
15269         {
15270           char *more_info = NULL;
15271           const char *reloc_name = howto->name;
15272
15273           if (reloc_dest != DEST_NORMAL)
15274             {
15275               more_info = bfd_malloc (strlen (reloc_name) + 8);
15276               if (more_info != NULL)
15277                 {
15278                   strcpy (more_info, reloc_name);
15279                   strcat (more_info, (reloc_dest == DEST_OPD
15280                                       ? " (OPD)" : " (stub)"));
15281                   reloc_name = more_info;
15282                 }
15283             }
15284
15285           if (r == bfd_reloc_overflow)
15286             {
15287               /* On code like "if (foo) foo();" don't report overflow
15288                  on a branch to zero when foo is undefined.  */
15289               if (!warned
15290                   && (reloc_dest == DEST_STUB
15291                       || !(h != NULL
15292                            && (h->elf.root.type == bfd_link_hash_undefweak
15293                                || h->elf.root.type == bfd_link_hash_undefined)
15294                            && is_branch_reloc (r_type))))
15295                 info->callbacks->reloc_overflow (info, &h->elf.root,
15296                                                  sym_name, reloc_name,
15297                                                  orig_rel.r_addend,
15298                                                  input_bfd, input_section,
15299                                                  rel->r_offset);
15300             }
15301           else
15302             {
15303               info->callbacks->einfo
15304                 /* xgettext:c-format */
15305                 (_("%H: %s against `%T': error %d\n"),
15306                  input_bfd, input_section, rel->r_offset,
15307                  reloc_name, sym_name, (int) r);
15308               ret = FALSE;
15309             }
15310           if (more_info != NULL)
15311             free (more_info);
15312         }
15313     copy_reloc:
15314       if (wrel != rel)
15315         *wrel = *rel;
15316     }
15317
15318   if (wrel != rel)
15319     {
15320       Elf_Internal_Shdr *rel_hdr;
15321       size_t deleted = rel - wrel;
15322
15323       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15324       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15325       if (rel_hdr->sh_size == 0)
15326         {
15327           /* It is too late to remove an empty reloc section.  Leave
15328              one NONE reloc.
15329              ??? What is wrong with an empty section???  */
15330           rel_hdr->sh_size = rel_hdr->sh_entsize;
15331           deleted -= 1;
15332         }
15333       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15334       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15335       input_section->reloc_count -= deleted;
15336     }
15337
15338   /* If we're emitting relocations, then shortly after this function
15339      returns, reloc offsets and addends for this section will be
15340      adjusted.  Worse, reloc symbol indices will be for the output
15341      file rather than the input.  Save a copy of the relocs for
15342      opd_entry_value.  */
15343   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15344     {
15345       bfd_size_type amt;
15346       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15347       rel = bfd_alloc (input_bfd, amt);
15348       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15349       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15350       if (rel == NULL)
15351         return FALSE;
15352       memcpy (rel, relocs, amt);
15353     }
15354   return ret;
15355 }
15356
15357 /* Adjust the value of any local symbols in opd sections.  */
15358
15359 static int
15360 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15361                               const char *name ATTRIBUTE_UNUSED,
15362                               Elf_Internal_Sym *elfsym,
15363                               asection *input_sec,
15364                               struct elf_link_hash_entry *h)
15365 {
15366   struct _opd_sec_data *opd;
15367   long adjust;
15368   bfd_vma value;
15369
15370   if (h != NULL)
15371     return 1;
15372
15373   opd = get_opd_info (input_sec);
15374   if (opd == NULL || opd->adjust == NULL)
15375     return 1;
15376
15377   value = elfsym->st_value - input_sec->output_offset;
15378   if (!bfd_link_relocatable (info))
15379     value -= input_sec->output_section->vma;
15380
15381   adjust = opd->adjust[OPD_NDX (value)];
15382   if (adjust == -1)
15383     return 2;
15384
15385   elfsym->st_value += adjust;
15386   return 1;
15387 }
15388
15389 /* Finish up dynamic symbol handling.  We set the contents of various
15390    dynamic sections here.  */
15391
15392 static bfd_boolean
15393 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15394                                  struct bfd_link_info *info,
15395                                  struct elf_link_hash_entry *h,
15396                                  Elf_Internal_Sym *sym)
15397 {
15398   struct ppc_link_hash_table *htab;
15399   struct plt_entry *ent;
15400   Elf_Internal_Rela rela;
15401   bfd_byte *loc;
15402
15403   htab = ppc_hash_table (info);
15404   if (htab == NULL)
15405     return FALSE;
15406
15407   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15408     if (ent->plt.offset != (bfd_vma) -1)
15409       {
15410         /* This symbol has an entry in the procedure linkage
15411            table.  Set it up.  */
15412         if (!htab->elf.dynamic_sections_created
15413             || h->dynindx == -1)
15414           {
15415             BFD_ASSERT (h->type == STT_GNU_IFUNC
15416                         && h->def_regular
15417                         && (h->root.type == bfd_link_hash_defined
15418                             || h->root.type == bfd_link_hash_defweak));
15419             rela.r_offset = (htab->elf.iplt->output_section->vma
15420                              + htab->elf.iplt->output_offset
15421                              + ent->plt.offset);
15422             if (htab->opd_abi)
15423               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15424             else
15425               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15426             rela.r_addend = (h->root.u.def.value
15427                              + h->root.u.def.section->output_offset
15428                              + h->root.u.def.section->output_section->vma
15429                              + ent->addend);
15430             loc = (htab->elf.irelplt->contents
15431                    + (htab->elf.irelplt->reloc_count++
15432                       * sizeof (Elf64_External_Rela)));
15433             htab->local_ifunc_resolver = 1;
15434           }
15435         else
15436           {
15437             rela.r_offset = (htab->elf.splt->output_section->vma
15438                              + htab->elf.splt->output_offset
15439                              + ent->plt.offset);
15440             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15441             rela.r_addend = ent->addend;
15442             loc = (htab->elf.srelplt->contents
15443                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15444                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15445             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15446               htab->maybe_local_ifunc_resolver = 1;
15447           }
15448         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15449
15450         if (!htab->opd_abi)
15451           {
15452             if (!h->def_regular)
15453               {
15454                 /* Mark the symbol as undefined, rather than as
15455                    defined in glink.  Leave the value if there were
15456                    any relocations where pointer equality matters
15457                    (this is a clue for the dynamic linker, to make
15458                    function pointer comparisons work between an
15459                    application and shared library), otherwise set it
15460                    to zero.  */
15461                 sym->st_shndx = SHN_UNDEF;
15462                 if (!h->pointer_equality_needed)
15463                   sym->st_value = 0;
15464                 else if (!h->ref_regular_nonweak)
15465                   {
15466                     /* This breaks function pointer comparisons, but
15467                        that is better than breaking tests for a NULL
15468                        function pointer.  */
15469                     sym->st_value = 0;
15470                   }
15471               }
15472           }
15473       }
15474
15475   if (h->needs_copy)
15476     {
15477       /* This symbol needs a copy reloc.  Set it up.  */
15478       asection *srel;
15479
15480       if (h->dynindx == -1
15481           || (h->root.type != bfd_link_hash_defined
15482               && h->root.type != bfd_link_hash_defweak)
15483           || htab->elf.srelbss == NULL
15484           || htab->elf.sreldynrelro == NULL)
15485         abort ();
15486
15487       rela.r_offset = (h->root.u.def.value
15488                        + h->root.u.def.section->output_section->vma
15489                        + h->root.u.def.section->output_offset);
15490       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15491       rela.r_addend = 0;
15492       if (h->root.u.def.section == htab->elf.sdynrelro)
15493         srel = htab->elf.sreldynrelro;
15494       else
15495         srel = htab->elf.srelbss;
15496       loc = srel->contents;
15497       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15498       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15499     }
15500
15501   return TRUE;
15502 }
15503
15504 /* Used to decide how to sort relocs in an optimal manner for the
15505    dynamic linker, before writing them out.  */
15506
15507 static enum elf_reloc_type_class
15508 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15509                             const asection *rel_sec,
15510                             const Elf_Internal_Rela *rela)
15511 {
15512   enum elf_ppc64_reloc_type r_type;
15513   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15514
15515   if (rel_sec == htab->elf.irelplt)
15516     return reloc_class_ifunc;
15517
15518   r_type = ELF64_R_TYPE (rela->r_info);
15519   switch (r_type)
15520     {
15521     case R_PPC64_RELATIVE:
15522       return reloc_class_relative;
15523     case R_PPC64_JMP_SLOT:
15524       return reloc_class_plt;
15525     case R_PPC64_COPY:
15526       return reloc_class_copy;
15527     default:
15528       return reloc_class_normal;
15529     }
15530 }
15531
15532 /* Finish up the dynamic sections.  */
15533
15534 static bfd_boolean
15535 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15536                                    struct bfd_link_info *info)
15537 {
15538   struct ppc_link_hash_table *htab;
15539   bfd *dynobj;
15540   asection *sdyn;
15541
15542   htab = ppc_hash_table (info);
15543   if (htab == NULL)
15544     return FALSE;
15545
15546   dynobj = htab->elf.dynobj;
15547   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15548
15549   if (htab->elf.dynamic_sections_created)
15550     {
15551       Elf64_External_Dyn *dyncon, *dynconend;
15552
15553       if (sdyn == NULL || htab->elf.sgot == NULL)
15554         abort ();
15555
15556       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15557       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15558       for (; dyncon < dynconend; dyncon++)
15559         {
15560           Elf_Internal_Dyn dyn;
15561           asection *s;
15562
15563           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15564
15565           switch (dyn.d_tag)
15566             {
15567             default:
15568               continue;
15569
15570             case DT_PPC64_GLINK:
15571               s = htab->glink;
15572               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15573               /* We stupidly defined DT_PPC64_GLINK to be the start
15574                  of glink rather than the first entry point, which is
15575                  what ld.so needs, and now have a bigger stub to
15576                  support automatic multiple TOCs.  */
15577               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15578               break;
15579
15580             case DT_PPC64_OPD:
15581               s = bfd_get_section_by_name (output_bfd, ".opd");
15582               if (s == NULL)
15583                 continue;
15584               dyn.d_un.d_ptr = s->vma;
15585               break;
15586
15587             case DT_PPC64_OPT:
15588               if (htab->do_multi_toc && htab->multi_toc_needed)
15589                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15590               if (htab->has_plt_localentry0)
15591                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15592               break;
15593
15594             case DT_PPC64_OPDSZ:
15595               s = bfd_get_section_by_name (output_bfd, ".opd");
15596               if (s == NULL)
15597                 continue;
15598               dyn.d_un.d_val = s->size;
15599               break;
15600
15601             case DT_PLTGOT:
15602               s = htab->elf.splt;
15603               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15604               break;
15605
15606             case DT_JMPREL:
15607               s = htab->elf.srelplt;
15608               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15609               break;
15610
15611             case DT_PLTRELSZ:
15612               dyn.d_un.d_val = htab->elf.srelplt->size;
15613               break;
15614
15615             case DT_TEXTREL:
15616               if (htab->local_ifunc_resolver)
15617                 info->callbacks->einfo
15618                   (_("%X%P: text relocations and GNU indirect "
15619                      "functions will result in a segfault at runtime\n"));
15620               else if (htab->maybe_local_ifunc_resolver)
15621                 info->callbacks->einfo
15622                   (_("%P: warning: text relocations and GNU indirect "
15623                      "functions may result in a segfault at runtime\n"));
15624               continue;
15625             }
15626
15627           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15628         }
15629     }
15630
15631   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15632       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15633     {
15634       /* Fill in the first entry in the global offset table.
15635          We use it to hold the link-time TOCbase.  */
15636       bfd_put_64 (output_bfd,
15637                   elf_gp (output_bfd) + TOC_BASE_OFF,
15638                   htab->elf.sgot->contents);
15639
15640       /* Set .got entry size.  */
15641       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15642     }
15643
15644   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15645       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15646     {
15647       /* Set .plt entry size.  */
15648       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15649         = PLT_ENTRY_SIZE (htab);
15650     }
15651
15652   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15653      brlt ourselves if emitrelocations.  */
15654   if (htab->brlt != NULL
15655       && htab->brlt->reloc_count != 0
15656       && !_bfd_elf_link_output_relocs (output_bfd,
15657                                        htab->brlt,
15658                                        elf_section_data (htab->brlt)->rela.hdr,
15659                                        elf_section_data (htab->brlt)->relocs,
15660                                        NULL))
15661     return FALSE;
15662
15663   if (htab->glink != NULL
15664       && htab->glink->reloc_count != 0
15665       && !_bfd_elf_link_output_relocs (output_bfd,
15666                                        htab->glink,
15667                                        elf_section_data (htab->glink)->rela.hdr,
15668                                        elf_section_data (htab->glink)->relocs,
15669                                        NULL))
15670     return FALSE;
15671
15672   if (htab->glink_eh_frame != NULL
15673       && htab->glink_eh_frame->size != 0)
15674     {
15675       bfd_vma val;
15676       bfd_byte *p;
15677       struct map_stub *group;
15678       size_t align = 4;
15679
15680       p = htab->glink_eh_frame->contents;
15681       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15682
15683       for (group = htab->group; group != NULL; group = group->next)
15684         if (group->stub_sec != NULL)
15685           {
15686             /* Offset to stub section.  */
15687             val = (group->stub_sec->output_section->vma
15688                    + group->stub_sec->output_offset);
15689             val -= (htab->glink_eh_frame->output_section->vma
15690                     + htab->glink_eh_frame->output_offset
15691                     + (p + 8 - htab->glink_eh_frame->contents));
15692             if (val + 0x80000000 > 0xffffffff)
15693               {
15694                 info->callbacks->einfo
15695                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15696                    group->stub_sec->name);
15697                 return FALSE;
15698               }
15699             bfd_put_32 (dynobj, val, p + 8);
15700             p += stub_eh_frame_size (group, align);
15701           }
15702       if (htab->glink != NULL && htab->glink->size != 0)
15703         {
15704           /* Offset to .glink.  */
15705           val = (htab->glink->output_section->vma
15706                  + htab->glink->output_offset
15707                  + 8);
15708           val -= (htab->glink_eh_frame->output_section->vma
15709                   + htab->glink_eh_frame->output_offset
15710                   + (p + 8 - htab->glink_eh_frame->contents));
15711           if (val + 0x80000000 > 0xffffffff)
15712             {
15713               info->callbacks->einfo
15714                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15715                  htab->glink->name);
15716               return FALSE;
15717             }
15718           bfd_put_32 (dynobj, val, p + 8);
15719           p += (24 + align - 1) & -align;
15720         }
15721
15722       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15723           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15724                                                htab->glink_eh_frame,
15725                                                htab->glink_eh_frame->contents))
15726         return FALSE;
15727     }
15728
15729   /* We need to handle writing out multiple GOT sections ourselves,
15730      since we didn't add them to DYNOBJ.  We know dynobj is the first
15731      bfd.  */
15732   while ((dynobj = dynobj->link.next) != NULL)
15733     {
15734       asection *s;
15735
15736       if (!is_ppc64_elf (dynobj))
15737         continue;
15738
15739       s = ppc64_elf_tdata (dynobj)->got;
15740       if (s != NULL
15741           && s->size != 0
15742           && s->output_section != bfd_abs_section_ptr
15743           && !bfd_set_section_contents (output_bfd, s->output_section,
15744                                         s->contents, s->output_offset,
15745                                         s->size))
15746         return FALSE;
15747       s = ppc64_elf_tdata (dynobj)->relgot;
15748       if (s != NULL
15749           && s->size != 0
15750           && s->output_section != bfd_abs_section_ptr
15751           && !bfd_set_section_contents (output_bfd, s->output_section,
15752                                         s->contents, s->output_offset,
15753                                         s->size))
15754         return FALSE;
15755     }
15756
15757   return TRUE;
15758 }
15759
15760 #include "elf64-target.h"
15761
15762 /* FreeBSD support */
15763
15764 #undef  TARGET_LITTLE_SYM
15765 #undef  TARGET_LITTLE_NAME
15766
15767 #undef  TARGET_BIG_SYM
15768 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15769 #undef  TARGET_BIG_NAME
15770 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15771
15772 #undef  ELF_OSABI
15773 #define ELF_OSABI       ELFOSABI_FREEBSD
15774
15775 #undef  elf64_bed
15776 #define elf64_bed       elf64_powerpc_fbsd_bed
15777
15778 #include "elf64-target.h"