bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2017 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x10000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_want_dynrelro 1
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_dtrel_excludes_plt 1
  80 #define elf_backend_default_execstack 0
  81
  82 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  83 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  84 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  85 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  86 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  87 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  88 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91 #define bfd_elf64_bfd_gc_sections             ppc64_elf_gc_sections
  92
  93 #define elf_backend_object_p                  ppc64_elf_object_p
  94 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  95 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  96 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  97 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
  98 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  99 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
 100 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
 101 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 102 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 103 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 104 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 105 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 106 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 107 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 108 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 109 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 110 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 111 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 112 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 113 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 114 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 115 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 116 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 117 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 118 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 119 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 120 #define elf_backend_special_sections          ppc64_elf_special_sections
 121 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 122 #define elf_backend_merge_symbol              ppc64_elf_merge_symbol
 123 #define elf_backend_get_reloc_section         bfd_get_section_by_name
 124
 125 /* The name of the dynamic interpreter.  This is put in the .interp
 126    section.  */
 127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 128
 129 /* The size in bytes of an entry in the procedure linkage table.  */
 130 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 131
 132 /* The initial size of the plt reserved for the dynamic linker.  */
 133 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 134
 135 /* Offsets to some stack save slots.  */
 136 #define STK_LR 16
 137 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 138 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 139    CR save slot.  Used only by optimised __tls_get_addr call stub,
 140    relying on __tls_get_addr_opt not saving CR..  */
 141 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 142
 143 /* TOC base pointers offset from start of TOC.  */
 144 #define TOC_BASE_OFF    0x8000
 145 /* TOC base alignment.  */
 146 #define TOC_BASE_ALIGN  256
 147
 148 /* Offset of tp and dtp pointers from start of TLS block.  */
 149 #define TP_OFFSET       0x7000
 150 #define DTP_OFFSET      0x8000
 151
 152 /* .plt call stub instructions.  The normal stub is like this, but
 153    sometimes the .plt entry crosses a 64k boundary and we need to
 154    insert an addi to adjust r11.  */
 155 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 156 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 157 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 158 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 159 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 160 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 161 #define BCTR            0x4e800420      /* bctr                      */
 162
 163 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 164 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 165 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 166
 167 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 168 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 169 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 170 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 171 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 172 #define BNECTR          0x4ca20420      /* bnectr+               */
 173 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 174
 175 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 176 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 177 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 178
 179 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 180 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 181 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 182
 183 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 184 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 185 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 186 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 187 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 188
 189 /* glink call stub instructions.  We enter with the index in R0.  */
 190 #define GLINK_CALL_STUB_SIZE (16*4)
 191                                         /* 0:                           */
 192                                         /*  .quad plt0-1f               */
 193                                         /* __glink:                     */
 194 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 195 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 196                                         /* 1:                           */
 197 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 198                                         /*  ld %2,(0b-1b)(%11)          */
 199 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 200 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 201                                         /*  ld %12,0(%11)               */
 202                                         /*  ld %2,8(%11)                */
 203                                         /*  mtctr %12                   */
 204                                         /*  ld %11,16(%11)              */
 205                                         /*  bctr                        */
 206 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 207 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 208 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 209 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 210 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 211
 212 /* Pad with this.  */
 213 #define NOP             0x60000000
 214
 215 /* Some other nops.  */
 216 #define CROR_151515     0x4def7b82
 217 #define CROR_313131     0x4ffffb82
 218
 219 /* .glink entries for the first 32k functions are two instructions.  */
 220 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 221 #define B_DOT           0x48000000      /* b     .              */
 222
 223 /* After that, we need two instructions to load the index, followed by
 224    a branch.  */
 225 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 226 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 227
 228 /* Instructions used by the save and restore reg functions.  */
 229 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 230 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 231 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 232 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 233 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 234 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 235 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 236 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 237 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 238 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 239 #define BLR             0x4e800020      /* blr                  */
 240
 241 /* Since .opd is an array of descriptors and each entry will end up
 242    with identical R_PPC64_RELATIVE relocs, there is really no need to
 243    propagate .opd relocs;  The dynamic linker should be taught to
 244    relocate .opd without reloc entries.  */
 245 #ifndef NO_OPD_RELOCS
 246 #define NO_OPD_RELOCS 0
 247 #endif
 248
 249 #ifndef ARRAY_SIZE
 250 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 251 #endif
 252
 253 static inline int
 254 abiversion (bfd *abfd)
 255 {
 256   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 257 }
 258
 259 static inline void
 260 set_abiversion (bfd *abfd, int ver)
 261 {
 262   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 263   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 264 }
 265 \f
 266 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 267
 268 /* Relocation HOWTO's.  */
 269 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 270
 271 static reloc_howto_type ppc64_elf_howto_raw[] = {
 272   /* This reloc does nothing.  */
 273   HOWTO (R_PPC64_NONE,          /* type */
 274          0,                     /* rightshift */
 275          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 276          0,                     /* bitsize */
 277          FALSE,                 /* pc_relative */
 278          0,                     /* bitpos */
 279          complain_overflow_dont, /* complain_on_overflow */
 280          bfd_elf_generic_reloc, /* special_function */
 281          "R_PPC64_NONE",        /* name */
 282          FALSE,                 /* partial_inplace */
 283          0,                     /* src_mask */
 284          0,                     /* dst_mask */
 285          FALSE),                /* pcrel_offset */
 286
 287   /* A standard 32 bit relocation.  */
 288   HOWTO (R_PPC64_ADDR32,        /* type */
 289          0,                     /* rightshift */
 290          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 291          32,                    /* bitsize */
 292          FALSE,                 /* pc_relative */
 293          0,                     /* bitpos */
 294          complain_overflow_bitfield, /* complain_on_overflow */
 295          bfd_elf_generic_reloc, /* special_function */
 296          "R_PPC64_ADDR32",      /* name */
 297          FALSE,                 /* partial_inplace */
 298          0,                     /* src_mask */
 299          0xffffffff,            /* dst_mask */
 300          FALSE),                /* pcrel_offset */
 301
 302   /* An absolute 26 bit branch; the lower two bits must be zero.
 303      FIXME: we don't check that, we just clear them.  */
 304   HOWTO (R_PPC64_ADDR24,        /* type */
 305          0,                     /* rightshift */
 306          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 307          26,                    /* bitsize */
 308          FALSE,                 /* pc_relative */
 309          0,                     /* bitpos */
 310          complain_overflow_bitfield, /* complain_on_overflow */
 311          bfd_elf_generic_reloc, /* special_function */
 312          "R_PPC64_ADDR24",      /* name */
 313          FALSE,                 /* partial_inplace */
 314          0,                     /* src_mask */
 315          0x03fffffc,            /* dst_mask */
 316          FALSE),                /* pcrel_offset */
 317
 318   /* A standard 16 bit relocation.  */
 319   HOWTO (R_PPC64_ADDR16,        /* type */
 320          0,                     /* rightshift */
 321          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 322          16,                    /* bitsize */
 323          FALSE,                 /* pc_relative */
 324          0,                     /* bitpos */
 325          complain_overflow_bitfield, /* complain_on_overflow */
 326          bfd_elf_generic_reloc, /* special_function */
 327          "R_PPC64_ADDR16",      /* name */
 328          FALSE,                 /* partial_inplace */
 329          0,                     /* src_mask */
 330          0xffff,                /* dst_mask */
 331          FALSE),                /* pcrel_offset */
 332
 333   /* A 16 bit relocation without overflow.  */
 334   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 335          0,                     /* rightshift */
 336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 337          16,                    /* bitsize */
 338          FALSE,                 /* pc_relative */
 339          0,                     /* bitpos */
 340          complain_overflow_dont,/* complain_on_overflow */
 341          bfd_elf_generic_reloc, /* special_function */
 342          "R_PPC64_ADDR16_LO",   /* name */
 343          FALSE,                 /* partial_inplace */
 344          0,                     /* src_mask */
 345          0xffff,                /* dst_mask */
 346          FALSE),                /* pcrel_offset */
 347
 348   /* Bits 16-31 of an address.  */
 349   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 350          16,                    /* rightshift */
 351          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 352          16,                    /* bitsize */
 353          FALSE,                 /* pc_relative */
 354          0,                     /* bitpos */
 355          complain_overflow_signed, /* complain_on_overflow */
 356          bfd_elf_generic_reloc, /* special_function */
 357          "R_PPC64_ADDR16_HI",   /* name */
 358          FALSE,                 /* partial_inplace */
 359          0,                     /* src_mask */
 360          0xffff,                /* dst_mask */
 361          FALSE),                /* pcrel_offset */
 362
 363   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 364      bits, treated as a signed number, is negative.  */
 365   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 366          16,                    /* rightshift */
 367          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 368          16,                    /* bitsize */
 369          FALSE,                 /* pc_relative */
 370          0,                     /* bitpos */
 371          complain_overflow_signed, /* complain_on_overflow */
 372          ppc64_elf_ha_reloc,    /* special_function */
 373          "R_PPC64_ADDR16_HA",   /* name */
 374          FALSE,                 /* partial_inplace */
 375          0,                     /* src_mask */
 376          0xffff,                /* dst_mask */
 377          FALSE),                /* pcrel_offset */
 378
 379   /* An absolute 16 bit branch; the lower two bits must be zero.
 380      FIXME: we don't check that, we just clear them.  */
 381   HOWTO (R_PPC64_ADDR14,        /* type */
 382          0,                     /* rightshift */
 383          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 384          16,                    /* bitsize */
 385          FALSE,                 /* pc_relative */
 386          0,                     /* bitpos */
 387          complain_overflow_signed, /* complain_on_overflow */
 388          ppc64_elf_branch_reloc, /* special_function */
 389          "R_PPC64_ADDR14",      /* name */
 390          FALSE,                 /* partial_inplace */
 391          0,                     /* src_mask */
 392          0x0000fffc,            /* dst_mask */
 393          FALSE),                /* pcrel_offset */
 394
 395   /* An absolute 16 bit branch, for which bit 10 should be set to
 396      indicate that the branch is expected to be taken.  The lower two
 397      bits must be zero.  */
 398   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 399          0,                     /* rightshift */
 400          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 401          16,                    /* bitsize */
 402          FALSE,                 /* pc_relative */
 403          0,                     /* bitpos */
 404          complain_overflow_signed, /* complain_on_overflow */
 405          ppc64_elf_brtaken_reloc, /* special_function */
 406          "R_PPC64_ADDR14_BRTAKEN",/* name */
 407          FALSE,                 /* partial_inplace */
 408          0,                     /* src_mask */
 409          0x0000fffc,            /* dst_mask */
 410          FALSE),                /* pcrel_offset */
 411
 412   /* An absolute 16 bit branch, for which bit 10 should be set to
 413      indicate that the branch is not expected to be taken.  The lower
 414      two bits must be zero.  */
 415   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 416          0,                     /* rightshift */
 417          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          16,                    /* bitsize */
 419          FALSE,                 /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_signed, /* complain_on_overflow */
 422          ppc64_elf_brtaken_reloc, /* special_function */
 423          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 424          FALSE,                 /* partial_inplace */
 425          0,                     /* src_mask */
 426          0x0000fffc,            /* dst_mask */
 427          FALSE),                /* pcrel_offset */
 428
 429   /* A relative 26 bit branch; the lower two bits must be zero.  */
 430   HOWTO (R_PPC64_REL24,         /* type */
 431          0,                     /* rightshift */
 432          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 433          26,                    /* bitsize */
 434          TRUE,                  /* pc_relative */
 435          0,                     /* bitpos */
 436          complain_overflow_signed, /* complain_on_overflow */
 437          ppc64_elf_branch_reloc, /* special_function */
 438          "R_PPC64_REL24",       /* name */
 439          FALSE,                 /* partial_inplace */
 440          0,                     /* src_mask */
 441          0x03fffffc,            /* dst_mask */
 442          TRUE),                 /* pcrel_offset */
 443
 444   /* A relative 16 bit branch; the lower two bits must be zero.  */
 445   HOWTO (R_PPC64_REL14,         /* type */
 446          0,                     /* rightshift */
 447          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 448          16,                    /* bitsize */
 449          TRUE,                  /* pc_relative */
 450          0,                     /* bitpos */
 451          complain_overflow_signed, /* complain_on_overflow */
 452          ppc64_elf_branch_reloc, /* special_function */
 453          "R_PPC64_REL14",       /* name */
 454          FALSE,                 /* partial_inplace */
 455          0,                     /* src_mask */
 456          0x0000fffc,            /* dst_mask */
 457          TRUE),                 /* pcrel_offset */
 458
 459   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 460      the branch is expected to be taken.  The lower two bits must be
 461      zero.  */
 462   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 463          0,                     /* rightshift */
 464          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 465          16,                    /* bitsize */
 466          TRUE,                  /* pc_relative */
 467          0,                     /* bitpos */
 468          complain_overflow_signed, /* complain_on_overflow */
 469          ppc64_elf_brtaken_reloc, /* special_function */
 470          "R_PPC64_REL14_BRTAKEN", /* name */
 471          FALSE,                 /* partial_inplace */
 472          0,                     /* src_mask */
 473          0x0000fffc,            /* dst_mask */
 474          TRUE),                 /* pcrel_offset */
 475
 476   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 477      the branch is not expected to be taken.  The lower two bits must
 478      be zero.  */
 479   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 480          0,                     /* rightshift */
 481          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 482          16,                    /* bitsize */
 483          TRUE,                  /* pc_relative */
 484          0,                     /* bitpos */
 485          complain_overflow_signed, /* complain_on_overflow */
 486          ppc64_elf_brtaken_reloc, /* special_function */
 487          "R_PPC64_REL14_BRNTAKEN",/* name */
 488          FALSE,                 /* partial_inplace */
 489          0,                     /* src_mask */
 490          0x0000fffc,            /* dst_mask */
 491          TRUE),                 /* pcrel_offset */
 492
 493   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 494      symbol.  */
 495   HOWTO (R_PPC64_GOT16,         /* type */
 496          0,                     /* rightshift */
 497          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 498          16,                    /* bitsize */
 499          FALSE,                 /* pc_relative */
 500          0,                     /* bitpos */
 501          complain_overflow_signed, /* complain_on_overflow */
 502          ppc64_elf_unhandled_reloc, /* special_function */
 503          "R_PPC64_GOT16",       /* name */
 504          FALSE,                 /* partial_inplace */
 505          0,                     /* src_mask */
 506          0xffff,                /* dst_mask */
 507          FALSE),                /* pcrel_offset */
 508
 509   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 510      the symbol.  */
 511   HOWTO (R_PPC64_GOT16_LO,      /* type */
 512          0,                     /* rightshift */
 513          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 514          16,                    /* bitsize */
 515          FALSE,                 /* pc_relative */
 516          0,                     /* bitpos */
 517          complain_overflow_dont, /* complain_on_overflow */
 518          ppc64_elf_unhandled_reloc, /* special_function */
 519          "R_PPC64_GOT16_LO",    /* name */
 520          FALSE,                 /* partial_inplace */
 521          0,                     /* src_mask */
 522          0xffff,                /* dst_mask */
 523          FALSE),                /* pcrel_offset */
 524
 525   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 526      the symbol.  */
 527   HOWTO (R_PPC64_GOT16_HI,      /* type */
 528          16,                    /* rightshift */
 529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 530          16,                    /* bitsize */
 531          FALSE,                 /* pc_relative */
 532          0,                     /* bitpos */
 533          complain_overflow_signed,/* complain_on_overflow */
 534          ppc64_elf_unhandled_reloc, /* special_function */
 535          "R_PPC64_GOT16_HI",    /* name */
 536          FALSE,                 /* partial_inplace */
 537          0,                     /* src_mask */
 538          0xffff,                /* dst_mask */
 539          FALSE),                /* pcrel_offset */
 540
 541   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 542      the symbol.  */
 543   HOWTO (R_PPC64_GOT16_HA,      /* type */
 544          16,                    /* rightshift */
 545          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          16,                    /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_signed,/* complain_on_overflow */
 550          ppc64_elf_unhandled_reloc, /* special_function */
 551          "R_PPC64_GOT16_HA",    /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          0xffff,                /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* This is used only by the dynamic linker.  The symbol should exist
 558      both in the object being run and in some shared library.  The
 559      dynamic linker copies the data addressed by the symbol from the
 560      shared library into the object, because the object being
 561      run has to have the data at some particular address.  */
 562   HOWTO (R_PPC64_COPY,          /* type */
 563          0,                     /* rightshift */
 564          0,                     /* this one is variable size */
 565          0,                     /* bitsize */
 566          FALSE,                 /* pc_relative */
 567          0,                     /* bitpos */
 568          complain_overflow_dont, /* complain_on_overflow */
 569          ppc64_elf_unhandled_reloc, /* special_function */
 570          "R_PPC64_COPY",        /* name */
 571          FALSE,                 /* partial_inplace */
 572          0,                     /* src_mask */
 573          0,                     /* dst_mask */
 574          FALSE),                /* pcrel_offset */
 575
 576   /* Like R_PPC64_ADDR64, but used when setting global offset table
 577      entries.  */
 578   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 579          0,                     /* rightshift */
 580          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 581          64,                    /* bitsize */
 582          FALSE,                 /* pc_relative */
 583          0,                     /* bitpos */
 584          complain_overflow_dont, /* complain_on_overflow */
 585          ppc64_elf_unhandled_reloc,  /* special_function */
 586          "R_PPC64_GLOB_DAT",    /* name */
 587          FALSE,                 /* partial_inplace */
 588          0,                     /* src_mask */
 589          ONES (64),             /* dst_mask */
 590          FALSE),                /* pcrel_offset */
 591
 592   /* Created by the link editor.  Marks a procedure linkage table
 593      entry for a symbol.  */
 594   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 595          0,                     /* rightshift */
 596          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 597          0,                     /* bitsize */
 598          FALSE,                 /* pc_relative */
 599          0,                     /* bitpos */
 600          complain_overflow_dont, /* complain_on_overflow */
 601          ppc64_elf_unhandled_reloc, /* special_function */
 602          "R_PPC64_JMP_SLOT",    /* name */
 603          FALSE,                 /* partial_inplace */
 604          0,                     /* src_mask */
 605          0,                     /* dst_mask */
 606          FALSE),                /* pcrel_offset */
 607
 608   /* Used only by the dynamic linker.  When the object is run, this
 609      doubleword64 is set to the load address of the object, plus the
 610      addend.  */
 611   HOWTO (R_PPC64_RELATIVE,      /* type */
 612          0,                     /* rightshift */
 613          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 614          64,                    /* bitsize */
 615          FALSE,                 /* pc_relative */
 616          0,                     /* bitpos */
 617          complain_overflow_dont, /* complain_on_overflow */
 618          bfd_elf_generic_reloc, /* special_function */
 619          "R_PPC64_RELATIVE",    /* name */
 620          FALSE,                 /* partial_inplace */
 621          0,                     /* src_mask */
 622          ONES (64),             /* dst_mask */
 623          FALSE),                /* pcrel_offset */
 624
 625   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 626   HOWTO (R_PPC64_UADDR32,       /* type */
 627          0,                     /* rightshift */
 628          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 629          32,                    /* bitsize */
 630          FALSE,                 /* pc_relative */
 631          0,                     /* bitpos */
 632          complain_overflow_bitfield, /* complain_on_overflow */
 633          bfd_elf_generic_reloc, /* special_function */
 634          "R_PPC64_UADDR32",     /* name */
 635          FALSE,                 /* partial_inplace */
 636          0,                     /* src_mask */
 637          0xffffffff,            /* dst_mask */
 638          FALSE),                /* pcrel_offset */
 639
 640   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 641   HOWTO (R_PPC64_UADDR16,       /* type */
 642          0,                     /* rightshift */
 643          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 644          16,                    /* bitsize */
 645          FALSE,                 /* pc_relative */
 646          0,                     /* bitpos */
 647          complain_overflow_bitfield, /* complain_on_overflow */
 648          bfd_elf_generic_reloc, /* special_function */
 649          "R_PPC64_UADDR16",     /* name */
 650          FALSE,                 /* partial_inplace */
 651          0,                     /* src_mask */
 652          0xffff,                /* dst_mask */
 653          FALSE),                /* pcrel_offset */
 654
 655   /* 32-bit PC relative.  */
 656   HOWTO (R_PPC64_REL32,         /* type */
 657          0,                     /* rightshift */
 658          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 659          32,                    /* bitsize */
 660          TRUE,                  /* pc_relative */
 661          0,                     /* bitpos */
 662          complain_overflow_signed, /* complain_on_overflow */
 663          bfd_elf_generic_reloc, /* special_function */
 664          "R_PPC64_REL32",       /* name */
 665          FALSE,                 /* partial_inplace */
 666          0,                     /* src_mask */
 667          0xffffffff,            /* dst_mask */
 668          TRUE),                 /* pcrel_offset */
 669
 670   /* 32-bit relocation to the symbol's procedure linkage table.  */
 671   HOWTO (R_PPC64_PLT32,         /* type */
 672          0,                     /* rightshift */
 673          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 674          32,                    /* bitsize */
 675          FALSE,                 /* pc_relative */
 676          0,                     /* bitpos */
 677          complain_overflow_bitfield, /* complain_on_overflow */
 678          ppc64_elf_unhandled_reloc, /* special_function */
 679          "R_PPC64_PLT32",       /* name */
 680          FALSE,                 /* partial_inplace */
 681          0,                     /* src_mask */
 682          0xffffffff,            /* dst_mask */
 683          FALSE),                /* pcrel_offset */
 684
 685   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 686      FIXME: R_PPC64_PLTREL32 not supported.  */
 687   HOWTO (R_PPC64_PLTREL32,      /* type */
 688          0,                     /* rightshift */
 689          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          32,                    /* bitsize */
 691          TRUE,                  /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_signed, /* complain_on_overflow */
 694          ppc64_elf_unhandled_reloc, /* special_function */
 695          "R_PPC64_PLTREL32",    /* name */
 696          FALSE,                 /* partial_inplace */
 697          0,                     /* src_mask */
 698          0xffffffff,            /* dst_mask */
 699          TRUE),                 /* pcrel_offset */
 700
 701   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 702      the symbol.  */
 703   HOWTO (R_PPC64_PLT16_LO,      /* type */
 704          0,                     /* rightshift */
 705          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 706          16,                    /* bitsize */
 707          FALSE,                 /* pc_relative */
 708          0,                     /* bitpos */
 709          complain_overflow_dont, /* complain_on_overflow */
 710          ppc64_elf_unhandled_reloc, /* special_function */
 711          "R_PPC64_PLT16_LO",    /* name */
 712          FALSE,                 /* partial_inplace */
 713          0,                     /* src_mask */
 714          0xffff,                /* dst_mask */
 715          FALSE),                /* pcrel_offset */
 716
 717   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 718      the symbol.  */
 719   HOWTO (R_PPC64_PLT16_HI,      /* type */
 720          16,                    /* rightshift */
 721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 722          16,                    /* bitsize */
 723          FALSE,                 /* pc_relative */
 724          0,                     /* bitpos */
 725          complain_overflow_signed, /* complain_on_overflow */
 726          ppc64_elf_unhandled_reloc, /* special_function */
 727          "R_PPC64_PLT16_HI",    /* name */
 728          FALSE,                 /* partial_inplace */
 729          0,                     /* src_mask */
 730          0xffff,                /* dst_mask */
 731          FALSE),                /* pcrel_offset */
 732
 733   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 734      the symbol.  */
 735   HOWTO (R_PPC64_PLT16_HA,      /* type */
 736          16,                    /* rightshift */
 737          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 738          16,                    /* bitsize */
 739          FALSE,                 /* pc_relative */
 740          0,                     /* bitpos */
 741          complain_overflow_signed, /* complain_on_overflow */
 742          ppc64_elf_unhandled_reloc, /* special_function */
 743          "R_PPC64_PLT16_HA",    /* name */
 744          FALSE,                 /* partial_inplace */
 745          0,                     /* src_mask */
 746          0xffff,                /* dst_mask */
 747          FALSE),                /* pcrel_offset */
 748
 749   /* 16-bit section relative relocation.  */
 750   HOWTO (R_PPC64_SECTOFF,       /* type */
 751          0,                     /* rightshift */
 752          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 753          16,                    /* bitsize */
 754          FALSE,                 /* pc_relative */
 755          0,                     /* bitpos */
 756          complain_overflow_signed, /* complain_on_overflow */
 757          ppc64_elf_sectoff_reloc, /* special_function */
 758          "R_PPC64_SECTOFF",     /* name */
 759          FALSE,                 /* partial_inplace */
 760          0,                     /* src_mask */
 761          0xffff,                /* dst_mask */
 762          FALSE),                /* pcrel_offset */
 763
 764   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 765   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 766          0,                     /* rightshift */
 767          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 768          16,                    /* bitsize */
 769          FALSE,                 /* pc_relative */
 770          0,                     /* bitpos */
 771          complain_overflow_dont, /* complain_on_overflow */
 772          ppc64_elf_sectoff_reloc, /* special_function */
 773          "R_PPC64_SECTOFF_LO",  /* name */
 774          FALSE,                 /* partial_inplace */
 775          0,                     /* src_mask */
 776          0xffff,                /* dst_mask */
 777          FALSE),                /* pcrel_offset */
 778
 779   /* 16-bit upper half section relative relocation.  */
 780   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 781          16,                    /* rightshift */
 782          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 783          16,                    /* bitsize */
 784          FALSE,                 /* pc_relative */
 785          0,                     /* bitpos */
 786          complain_overflow_signed, /* complain_on_overflow */
 787          ppc64_elf_sectoff_reloc, /* special_function */
 788          "R_PPC64_SECTOFF_HI",  /* name */
 789          FALSE,                 /* partial_inplace */
 790          0,                     /* src_mask */
 791          0xffff,                /* dst_mask */
 792          FALSE),                /* pcrel_offset */
 793
 794   /* 16-bit upper half adjusted section relative relocation.  */
 795   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 796          16,                    /* rightshift */
 797          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 798          16,                    /* bitsize */
 799          FALSE,                 /* pc_relative */
 800          0,                     /* bitpos */
 801          complain_overflow_signed, /* complain_on_overflow */
 802          ppc64_elf_sectoff_ha_reloc, /* special_function */
 803          "R_PPC64_SECTOFF_HA",  /* name */
 804          FALSE,                 /* partial_inplace */
 805          0,                     /* src_mask */
 806          0xffff,                /* dst_mask */
 807          FALSE),                /* pcrel_offset */
 808
 809   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 810   HOWTO (R_PPC64_REL30,         /* type */
 811          2,                     /* rightshift */
 812          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 813          30,                    /* bitsize */
 814          TRUE,                  /* pc_relative */
 815          0,                     /* bitpos */
 816          complain_overflow_dont, /* complain_on_overflow */
 817          bfd_elf_generic_reloc, /* special_function */
 818          "R_PPC64_REL30",       /* name */
 819          FALSE,                 /* partial_inplace */
 820          0,                     /* src_mask */
 821          0xfffffffc,            /* dst_mask */
 822          TRUE),                 /* pcrel_offset */
 823
 824   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 825
 826   /* A standard 64-bit relocation.  */
 827   HOWTO (R_PPC64_ADDR64,        /* type */
 828          0,                     /* rightshift */
 829          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 830          64,                    /* bitsize */
 831          FALSE,                 /* pc_relative */
 832          0,                     /* bitpos */
 833          complain_overflow_dont, /* complain_on_overflow */
 834          bfd_elf_generic_reloc, /* special_function */
 835          "R_PPC64_ADDR64",      /* name */
 836          FALSE,                 /* partial_inplace */
 837          0,                     /* src_mask */
 838          ONES (64),             /* dst_mask */
 839          FALSE),                /* pcrel_offset */
 840
 841   /* The bits 32-47 of an address.  */
 842   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 843          32,                    /* rightshift */
 844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 845          16,                    /* bitsize */
 846          FALSE,                 /* pc_relative */
 847          0,                     /* bitpos */
 848          complain_overflow_dont, /* complain_on_overflow */
 849          bfd_elf_generic_reloc, /* special_function */
 850          "R_PPC64_ADDR16_HIGHER", /* name */
 851          FALSE,                 /* partial_inplace */
 852          0,                     /* src_mask */
 853          0xffff,                /* dst_mask */
 854          FALSE),                /* pcrel_offset */
 855
 856   /* The bits 32-47 of an address, plus 1 if the contents of the low
 857      16 bits, treated as a signed number, is negative.  */
 858   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 859          32,                    /* rightshift */
 860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 861          16,                    /* bitsize */
 862          FALSE,                 /* pc_relative */
 863          0,                     /* bitpos */
 864          complain_overflow_dont, /* complain_on_overflow */
 865          ppc64_elf_ha_reloc,    /* special_function */
 866          "R_PPC64_ADDR16_HIGHERA", /* name */
 867          FALSE,                 /* partial_inplace */
 868          0,                     /* src_mask */
 869          0xffff,                /* dst_mask */
 870          FALSE),                /* pcrel_offset */
 871
 872   /* The bits 48-63 of an address.  */
 873   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 874          48,                    /* rightshift */
 875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 876          16,                    /* bitsize */
 877          FALSE,                 /* pc_relative */
 878          0,                     /* bitpos */
 879          complain_overflow_dont, /* complain_on_overflow */
 880          bfd_elf_generic_reloc, /* special_function */
 881          "R_PPC64_ADDR16_HIGHEST", /* name */
 882          FALSE,                 /* partial_inplace */
 883          0,                     /* src_mask */
 884          0xffff,                /* dst_mask */
 885          FALSE),                /* pcrel_offset */
 886
 887   /* The bits 48-63 of an address, plus 1 if the contents of the low
 888      16 bits, treated as a signed number, is negative.  */
 889   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 890          48,                    /* rightshift */
 891          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 892          16,                    /* bitsize */
 893          FALSE,                 /* pc_relative */
 894          0,                     /* bitpos */
 895          complain_overflow_dont, /* complain_on_overflow */
 896          ppc64_elf_ha_reloc,    /* special_function */
 897          "R_PPC64_ADDR16_HIGHESTA", /* name */
 898          FALSE,                 /* partial_inplace */
 899          0,                     /* src_mask */
 900          0xffff,                /* dst_mask */
 901          FALSE),                /* pcrel_offset */
 902
 903   /* Like ADDR64, but may be unaligned.  */
 904   HOWTO (R_PPC64_UADDR64,       /* type */
 905          0,                     /* rightshift */
 906          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 907          64,                    /* bitsize */
 908          FALSE,                 /* pc_relative */
 909          0,                     /* bitpos */
 910          complain_overflow_dont, /* complain_on_overflow */
 911          bfd_elf_generic_reloc, /* special_function */
 912          "R_PPC64_UADDR64",     /* name */
 913          FALSE,                 /* partial_inplace */
 914          0,                     /* src_mask */
 915          ONES (64),             /* dst_mask */
 916          FALSE),                /* pcrel_offset */
 917
 918   /* 64-bit relative relocation.  */
 919   HOWTO (R_PPC64_REL64,         /* type */
 920          0,                     /* rightshift */
 921          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 922          64,                    /* bitsize */
 923          TRUE,                  /* pc_relative */
 924          0,                     /* bitpos */
 925          complain_overflow_dont, /* complain_on_overflow */
 926          bfd_elf_generic_reloc, /* special_function */
 927          "R_PPC64_REL64",       /* name */
 928          FALSE,                 /* partial_inplace */
 929          0,                     /* src_mask */
 930          ONES (64),             /* dst_mask */
 931          TRUE),                 /* pcrel_offset */
 932
 933   /* 64-bit relocation to the symbol's procedure linkage table.  */
 934   HOWTO (R_PPC64_PLT64,         /* type */
 935          0,                     /* rightshift */
 936          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 937          64,                    /* bitsize */
 938          FALSE,                 /* pc_relative */
 939          0,                     /* bitpos */
 940          complain_overflow_dont, /* complain_on_overflow */
 941          ppc64_elf_unhandled_reloc, /* special_function */
 942          "R_PPC64_PLT64",       /* name */
 943          FALSE,                 /* partial_inplace */
 944          0,                     /* src_mask */
 945          ONES (64),             /* dst_mask */
 946          FALSE),                /* pcrel_offset */
 947
 948   /* 64-bit PC relative relocation to the symbol's procedure linkage
 949      table.  */
 950   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 951   HOWTO (R_PPC64_PLTREL64,      /* type */
 952          0,                     /* rightshift */
 953          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 954          64,                    /* bitsize */
 955          TRUE,                  /* pc_relative */
 956          0,                     /* bitpos */
 957          complain_overflow_dont, /* complain_on_overflow */
 958          ppc64_elf_unhandled_reloc, /* special_function */
 959          "R_PPC64_PLTREL64",    /* name */
 960          FALSE,                 /* partial_inplace */
 961          0,                     /* src_mask */
 962          ONES (64),             /* dst_mask */
 963          TRUE),                 /* pcrel_offset */
 964
 965   /* 16 bit TOC-relative relocation.  */
 966
 967   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 968   HOWTO (R_PPC64_TOC16,         /* type */
 969          0,                     /* rightshift */
 970          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 971          16,                    /* bitsize */
 972          FALSE,                 /* pc_relative */
 973          0,                     /* bitpos */
 974          complain_overflow_signed, /* complain_on_overflow */
 975          ppc64_elf_toc_reloc,   /* special_function */
 976          "R_PPC64_TOC16",       /* name */
 977          FALSE,                 /* partial_inplace */
 978          0,                     /* src_mask */
 979          0xffff,                /* dst_mask */
 980          FALSE),                /* pcrel_offset */
 981
 982   /* 16 bit TOC-relative relocation without overflow.  */
 983
 984   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 985   HOWTO (R_PPC64_TOC16_LO,      /* type */
 986          0,                     /* rightshift */
 987          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 988          16,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_dont, /* complain_on_overflow */
 992          ppc64_elf_toc_reloc,   /* special_function */
 993          "R_PPC64_TOC16_LO",    /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          0xffff,                /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* 16 bit TOC-relative relocation, high 16 bits.  */
1000
1001   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
1002   HOWTO (R_PPC64_TOC16_HI,      /* type */
1003          16,                    /* rightshift */
1004          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1005          16,                    /* bitsize */
1006          FALSE,                 /* pc_relative */
1007          0,                     /* bitpos */
1008          complain_overflow_signed, /* complain_on_overflow */
1009          ppc64_elf_toc_reloc,   /* special_function */
1010          "R_PPC64_TOC16_HI",    /* name */
1011          FALSE,                 /* partial_inplace */
1012          0,                     /* src_mask */
1013          0xffff,                /* dst_mask */
1014          FALSE),                /* pcrel_offset */
1015
1016   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1017      contents of the low 16 bits, treated as a signed number, is
1018      negative.  */
1019
1020   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1021   HOWTO (R_PPC64_TOC16_HA,      /* type */
1022          16,                    /* rightshift */
1023          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1024          16,                    /* bitsize */
1025          FALSE,                 /* pc_relative */
1026          0,                     /* bitpos */
1027          complain_overflow_signed, /* complain_on_overflow */
1028          ppc64_elf_toc_ha_reloc, /* special_function */
1029          "R_PPC64_TOC16_HA",    /* name */
1030          FALSE,                 /* partial_inplace */
1031          0,                     /* src_mask */
1032          0xffff,                /* dst_mask */
1033          FALSE),                /* pcrel_offset */
1034
1035   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1036
1037   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1038   HOWTO (R_PPC64_TOC,           /* type */
1039          0,                     /* rightshift */
1040          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1041          64,                    /* bitsize */
1042          FALSE,                 /* pc_relative */
1043          0,                     /* bitpos */
1044          complain_overflow_dont, /* complain_on_overflow */
1045          ppc64_elf_toc64_reloc, /* special_function */
1046          "R_PPC64_TOC",         /* name */
1047          FALSE,                 /* partial_inplace */
1048          0,                     /* src_mask */
1049          ONES (64),             /* dst_mask */
1050          FALSE),                /* pcrel_offset */
1051
1052   /* Like R_PPC64_GOT16, but also informs the link editor that the
1053      value to relocate may (!) refer to a PLT entry which the link
1054      editor (a) may replace with the symbol value.  If the link editor
1055      is unable to fully resolve the symbol, it may (b) create a PLT
1056      entry and store the address to the new PLT entry in the GOT.
1057      This permits lazy resolution of function symbols at run time.
1058      The link editor may also skip all of this and just (c) emit a
1059      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1060   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1061     HOWTO (R_PPC64_PLTGOT16,    /* type */
1062          0,                     /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_signed, /* complain_on_overflow */
1068          ppc64_elf_unhandled_reloc, /* special_function */
1069          "R_PPC64_PLTGOT16",    /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xffff,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1076   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1077   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1078          0,                     /* rightshift */
1079          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1080          16,                    /* bitsize */
1081          FALSE,                 /* pc_relative */
1082          0,                     /* bitpos */
1083          complain_overflow_dont, /* complain_on_overflow */
1084          ppc64_elf_unhandled_reloc, /* special_function */
1085          "R_PPC64_PLTGOT16_LO", /* name */
1086          FALSE,                 /* partial_inplace */
1087          0,                     /* src_mask */
1088          0xffff,                /* dst_mask */
1089          FALSE),                /* pcrel_offset */
1090
1091   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1092   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1093   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1094          16,                    /* rightshift */
1095          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1096          16,                    /* bitsize */
1097          FALSE,                 /* pc_relative */
1098          0,                     /* bitpos */
1099          complain_overflow_signed, /* complain_on_overflow */
1100          ppc64_elf_unhandled_reloc, /* special_function */
1101          "R_PPC64_PLTGOT16_HI", /* name */
1102          FALSE,                 /* partial_inplace */
1103          0,                     /* src_mask */
1104          0xffff,                /* dst_mask */
1105          FALSE),                /* pcrel_offset */
1106
1107   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1108      1 if the contents of the low 16 bits, treated as a signed number,
1109      is negative.  */
1110   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1111   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1112          16,                    /* rightshift */
1113          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1114          16,                    /* bitsize */
1115          FALSE,                 /* pc_relative */
1116          0,                     /* bitpos */
1117          complain_overflow_signed, /* complain_on_overflow */
1118          ppc64_elf_unhandled_reloc, /* special_function */
1119          "R_PPC64_PLTGOT16_HA", /* name */
1120          FALSE,                 /* partial_inplace */
1121          0,                     /* src_mask */
1122          0xffff,                /* dst_mask */
1123          FALSE),                /* pcrel_offset */
1124
1125   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1126   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1127          0,                     /* rightshift */
1128          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1129          16,                    /* bitsize */
1130          FALSE,                 /* pc_relative */
1131          0,                     /* bitpos */
1132          complain_overflow_signed, /* complain_on_overflow */
1133          bfd_elf_generic_reloc, /* special_function */
1134          "R_PPC64_ADDR16_DS",   /* name */
1135          FALSE,                 /* partial_inplace */
1136          0,                     /* src_mask */
1137          0xfffc,                /* dst_mask */
1138          FALSE),                /* pcrel_offset */
1139
1140   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1141   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1142          0,                     /* rightshift */
1143          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1144          16,                    /* bitsize */
1145          FALSE,                 /* pc_relative */
1146          0,                     /* bitpos */
1147          complain_overflow_dont,/* complain_on_overflow */
1148          bfd_elf_generic_reloc, /* special_function */
1149          "R_PPC64_ADDR16_LO_DS",/* name */
1150          FALSE,                 /* partial_inplace */
1151          0,                     /* src_mask */
1152          0xfffc,                /* dst_mask */
1153          FALSE),                /* pcrel_offset */
1154
1155   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1156   HOWTO (R_PPC64_GOT16_DS,      /* type */
1157          0,                     /* rightshift */
1158          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1159          16,                    /* bitsize */
1160          FALSE,                 /* pc_relative */
1161          0,                     /* bitpos */
1162          complain_overflow_signed, /* complain_on_overflow */
1163          ppc64_elf_unhandled_reloc, /* special_function */
1164          "R_PPC64_GOT16_DS",    /* name */
1165          FALSE,                 /* partial_inplace */
1166          0,                     /* src_mask */
1167          0xfffc,                /* dst_mask */
1168          FALSE),                /* pcrel_offset */
1169
1170   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1171   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1172          0,                     /* rightshift */
1173          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1174          16,                    /* bitsize */
1175          FALSE,                 /* pc_relative */
1176          0,                     /* bitpos */
1177          complain_overflow_dont, /* complain_on_overflow */
1178          ppc64_elf_unhandled_reloc, /* special_function */
1179          "R_PPC64_GOT16_LO_DS", /* name */
1180          FALSE,                 /* partial_inplace */
1181          0,                     /* src_mask */
1182          0xfffc,                /* dst_mask */
1183          FALSE),                /* pcrel_offset */
1184
1185   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1186   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1187          0,                     /* rightshift */
1188          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1189          16,                    /* bitsize */
1190          FALSE,                 /* pc_relative */
1191          0,                     /* bitpos */
1192          complain_overflow_dont, /* complain_on_overflow */
1193          ppc64_elf_unhandled_reloc, /* special_function */
1194          "R_PPC64_PLT16_LO_DS", /* name */
1195          FALSE,                 /* partial_inplace */
1196          0,                     /* src_mask */
1197          0xfffc,                /* dst_mask */
1198          FALSE),                /* pcrel_offset */
1199
1200   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1201   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1202          0,                     /* rightshift */
1203          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1204          16,                    /* bitsize */
1205          FALSE,                 /* pc_relative */
1206          0,                     /* bitpos */
1207          complain_overflow_signed, /* complain_on_overflow */
1208          ppc64_elf_sectoff_reloc, /* special_function */
1209          "R_PPC64_SECTOFF_DS",  /* name */
1210          FALSE,                 /* partial_inplace */
1211          0,                     /* src_mask */
1212          0xfffc,                /* dst_mask */
1213          FALSE),                /* pcrel_offset */
1214
1215   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1216   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1217          0,                     /* rightshift */
1218          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1219          16,                    /* bitsize */
1220          FALSE,                 /* pc_relative */
1221          0,                     /* bitpos */
1222          complain_overflow_dont, /* complain_on_overflow */
1223          ppc64_elf_sectoff_reloc, /* special_function */
1224          "R_PPC64_SECTOFF_LO_DS",/* name */
1225          FALSE,                 /* partial_inplace */
1226          0,                     /* src_mask */
1227          0xfffc,                /* dst_mask */
1228          FALSE),                /* pcrel_offset */
1229
1230   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1231   HOWTO (R_PPC64_TOC16_DS,      /* type */
1232          0,                     /* rightshift */
1233          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1234          16,                    /* bitsize */
1235          FALSE,                 /* pc_relative */
1236          0,                     /* bitpos */
1237          complain_overflow_signed, /* complain_on_overflow */
1238          ppc64_elf_toc_reloc,   /* special_function */
1239          "R_PPC64_TOC16_DS",    /* name */
1240          FALSE,                 /* partial_inplace */
1241          0,                     /* src_mask */
1242          0xfffc,                /* dst_mask */
1243          FALSE),                /* pcrel_offset */
1244
1245   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1246   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1247          0,                     /* rightshift */
1248          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1249          16,                    /* bitsize */
1250          FALSE,                 /* pc_relative */
1251          0,                     /* bitpos */
1252          complain_overflow_dont, /* complain_on_overflow */
1253          ppc64_elf_toc_reloc,   /* special_function */
1254          "R_PPC64_TOC16_LO_DS", /* name */
1255          FALSE,                 /* partial_inplace */
1256          0,                     /* src_mask */
1257          0xfffc,                /* dst_mask */
1258          FALSE),                /* pcrel_offset */
1259
1260   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1261   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1262   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1263          0,                     /* rightshift */
1264          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1265          16,                    /* bitsize */
1266          FALSE,                 /* pc_relative */
1267          0,                     /* bitpos */
1268          complain_overflow_signed, /* complain_on_overflow */
1269          ppc64_elf_unhandled_reloc, /* special_function */
1270          "R_PPC64_PLTGOT16_DS", /* name */
1271          FALSE,                 /* partial_inplace */
1272          0,                     /* src_mask */
1273          0xfffc,                /* dst_mask */
1274          FALSE),                /* pcrel_offset */
1275
1276   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1277   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1278   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1279          0,                     /* rightshift */
1280          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1281          16,                    /* bitsize */
1282          FALSE,                 /* pc_relative */
1283          0,                     /* bitpos */
1284          complain_overflow_dont, /* complain_on_overflow */
1285          ppc64_elf_unhandled_reloc, /* special_function */
1286          "R_PPC64_PLTGOT16_LO_DS",/* name */
1287          FALSE,                 /* partial_inplace */
1288          0,                     /* src_mask */
1289          0xfffc,                /* dst_mask */
1290          FALSE),                /* pcrel_offset */
1291
1292   /* Marker relocs for TLS.  */
1293   HOWTO (R_PPC64_TLS,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TLS",         /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   HOWTO (R_PPC64_TLSGD,
1308          0,                     /* rightshift */
1309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          32,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_dont, /* complain_on_overflow */
1314          bfd_elf_generic_reloc, /* special_function */
1315          "R_PPC64_TLSGD",       /* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0,                     /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   HOWTO (R_PPC64_TLSLD,
1322          0,                     /* rightshift */
1323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1324          32,                    /* bitsize */
1325          FALSE,                 /* pc_relative */
1326          0,                     /* bitpos */
1327          complain_overflow_dont, /* complain_on_overflow */
1328          bfd_elf_generic_reloc, /* special_function */
1329          "R_PPC64_TLSLD",       /* name */
1330          FALSE,                 /* partial_inplace */
1331          0,                     /* src_mask */
1332          0,                     /* dst_mask */
1333          FALSE),                /* pcrel_offset */
1334
1335   HOWTO (R_PPC64_TOCSAVE,
1336          0,                     /* rightshift */
1337          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1338          32,                    /* bitsize */
1339          FALSE,                 /* pc_relative */
1340          0,                     /* bitpos */
1341          complain_overflow_dont, /* complain_on_overflow */
1342          bfd_elf_generic_reloc, /* special_function */
1343          "R_PPC64_TOCSAVE",     /* name */
1344          FALSE,                 /* partial_inplace */
1345          0,                     /* src_mask */
1346          0,                     /* dst_mask */
1347          FALSE),                /* pcrel_offset */
1348
1349   /* Computes the load module index of the load module that contains the
1350      definition of its TLS sym.  */
1351   HOWTO (R_PPC64_DTPMOD64,
1352          0,                     /* rightshift */
1353          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1354          64,                    /* bitsize */
1355          FALSE,                 /* pc_relative */
1356          0,                     /* bitpos */
1357          complain_overflow_dont, /* complain_on_overflow */
1358          ppc64_elf_unhandled_reloc, /* special_function */
1359          "R_PPC64_DTPMOD64",    /* name */
1360          FALSE,                 /* partial_inplace */
1361          0,                     /* src_mask */
1362          ONES (64),             /* dst_mask */
1363          FALSE),                /* pcrel_offset */
1364
1365   /* Computes a dtv-relative displacement, the difference between the value
1366      of sym+add and the base address of the thread-local storage block that
1367      contains the definition of sym, minus 0x8000.  */
1368   HOWTO (R_PPC64_DTPREL64,
1369          0,                     /* rightshift */
1370          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1371          64,                    /* bitsize */
1372          FALSE,                 /* pc_relative */
1373          0,                     /* bitpos */
1374          complain_overflow_dont, /* complain_on_overflow */
1375          ppc64_elf_unhandled_reloc, /* special_function */
1376          "R_PPC64_DTPREL64",    /* name */
1377          FALSE,                 /* partial_inplace */
1378          0,                     /* src_mask */
1379          ONES (64),             /* dst_mask */
1380          FALSE),                /* pcrel_offset */
1381
1382   /* A 16 bit dtprel reloc.  */
1383   HOWTO (R_PPC64_DTPREL16,
1384          0,                     /* rightshift */
1385          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1386          16,                    /* bitsize */
1387          FALSE,                 /* pc_relative */
1388          0,                     /* bitpos */
1389          complain_overflow_signed, /* complain_on_overflow */
1390          ppc64_elf_unhandled_reloc, /* special_function */
1391          "R_PPC64_DTPREL16",    /* name */
1392          FALSE,                 /* partial_inplace */
1393          0,                     /* src_mask */
1394          0xffff,                /* dst_mask */
1395          FALSE),                /* pcrel_offset */
1396
1397   /* Like DTPREL16, but no overflow.  */
1398   HOWTO (R_PPC64_DTPREL16_LO,
1399          0,                     /* rightshift */
1400          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1401          16,                    /* bitsize */
1402          FALSE,                 /* pc_relative */
1403          0,                     /* bitpos */
1404          complain_overflow_dont, /* complain_on_overflow */
1405          ppc64_elf_unhandled_reloc, /* special_function */
1406          "R_PPC64_DTPREL16_LO", /* name */
1407          FALSE,                 /* partial_inplace */
1408          0,                     /* src_mask */
1409          0xffff,                /* dst_mask */
1410          FALSE),                /* pcrel_offset */
1411
1412   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1413   HOWTO (R_PPC64_DTPREL16_HI,
1414          16,                    /* rightshift */
1415          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1416          16,                    /* bitsize */
1417          FALSE,                 /* pc_relative */
1418          0,                     /* bitpos */
1419          complain_overflow_signed, /* complain_on_overflow */
1420          ppc64_elf_unhandled_reloc, /* special_function */
1421          "R_PPC64_DTPREL16_HI", /* name */
1422          FALSE,                 /* partial_inplace */
1423          0,                     /* src_mask */
1424          0xffff,                /* dst_mask */
1425          FALSE),                /* pcrel_offset */
1426
1427   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1428   HOWTO (R_PPC64_DTPREL16_HA,
1429          16,                    /* rightshift */
1430          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1431          16,                    /* bitsize */
1432          FALSE,                 /* pc_relative */
1433          0,                     /* bitpos */
1434          complain_overflow_signed, /* complain_on_overflow */
1435          ppc64_elf_unhandled_reloc, /* special_function */
1436          "R_PPC64_DTPREL16_HA", /* name */
1437          FALSE,                 /* partial_inplace */
1438          0,                     /* src_mask */
1439          0xffff,                /* dst_mask */
1440          FALSE),                /* pcrel_offset */
1441
1442   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1443   HOWTO (R_PPC64_DTPREL16_HIGHER,
1444          32,                    /* rightshift */
1445          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1446          16,                    /* bitsize */
1447          FALSE,                 /* pc_relative */
1448          0,                     /* bitpos */
1449          complain_overflow_dont, /* complain_on_overflow */
1450          ppc64_elf_unhandled_reloc, /* special_function */
1451          "R_PPC64_DTPREL16_HIGHER", /* name */
1452          FALSE,                 /* partial_inplace */
1453          0,                     /* src_mask */
1454          0xffff,                /* dst_mask */
1455          FALSE),                /* pcrel_offset */
1456
1457   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1458   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1459          32,                    /* rightshift */
1460          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1461          16,                    /* bitsize */
1462          FALSE,                 /* pc_relative */
1463          0,                     /* bitpos */
1464          complain_overflow_dont, /* complain_on_overflow */
1465          ppc64_elf_unhandled_reloc, /* special_function */
1466          "R_PPC64_DTPREL16_HIGHERA", /* name */
1467          FALSE,                 /* partial_inplace */
1468          0,                     /* src_mask */
1469          0xffff,                /* dst_mask */
1470          FALSE),                /* pcrel_offset */
1471
1472   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1473   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1474          48,                    /* rightshift */
1475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1476          16,                    /* bitsize */
1477          FALSE,                 /* pc_relative */
1478          0,                     /* bitpos */
1479          complain_overflow_dont, /* complain_on_overflow */
1480          ppc64_elf_unhandled_reloc, /* special_function */
1481          "R_PPC64_DTPREL16_HIGHEST", /* name */
1482          FALSE,                 /* partial_inplace */
1483          0,                     /* src_mask */
1484          0xffff,                /* dst_mask */
1485          FALSE),                /* pcrel_offset */
1486
1487   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1488   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1489          48,                    /* rightshift */
1490          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1491          16,                    /* bitsize */
1492          FALSE,                 /* pc_relative */
1493          0,                     /* bitpos */
1494          complain_overflow_dont, /* complain_on_overflow */
1495          ppc64_elf_unhandled_reloc, /* special_function */
1496          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1497          FALSE,                 /* partial_inplace */
1498          0,                     /* src_mask */
1499          0xffff,                /* dst_mask */
1500          FALSE),                /* pcrel_offset */
1501
1502   /* Like DTPREL16, but for insns with a DS field.  */
1503   HOWTO (R_PPC64_DTPREL16_DS,
1504          0,                     /* rightshift */
1505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1506          16,                    /* bitsize */
1507          FALSE,                 /* pc_relative */
1508          0,                     /* bitpos */
1509          complain_overflow_signed, /* complain_on_overflow */
1510          ppc64_elf_unhandled_reloc, /* special_function */
1511          "R_PPC64_DTPREL16_DS", /* name */
1512          FALSE,                 /* partial_inplace */
1513          0,                     /* src_mask */
1514          0xfffc,                /* dst_mask */
1515          FALSE),                /* pcrel_offset */
1516
1517   /* Like DTPREL16_DS, but no overflow.  */
1518   HOWTO (R_PPC64_DTPREL16_LO_DS,
1519          0,                     /* rightshift */
1520          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1521          16,                    /* bitsize */
1522          FALSE,                 /* pc_relative */
1523          0,                     /* bitpos */
1524          complain_overflow_dont, /* complain_on_overflow */
1525          ppc64_elf_unhandled_reloc, /* special_function */
1526          "R_PPC64_DTPREL16_LO_DS", /* name */
1527          FALSE,                 /* partial_inplace */
1528          0,                     /* src_mask */
1529          0xfffc,                /* dst_mask */
1530          FALSE),                /* pcrel_offset */
1531
1532   /* Computes a tp-relative displacement, the difference between the value of
1533      sym+add and the value of the thread pointer (r13).  */
1534   HOWTO (R_PPC64_TPREL64,
1535          0,                     /* rightshift */
1536          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1537          64,                    /* bitsize */
1538          FALSE,                 /* pc_relative */
1539          0,                     /* bitpos */
1540          complain_overflow_dont, /* complain_on_overflow */
1541          ppc64_elf_unhandled_reloc, /* special_function */
1542          "R_PPC64_TPREL64",     /* name */
1543          FALSE,                 /* partial_inplace */
1544          0,                     /* src_mask */
1545          ONES (64),             /* dst_mask */
1546          FALSE),                /* pcrel_offset */
1547
1548   /* A 16 bit tprel reloc.  */
1549   HOWTO (R_PPC64_TPREL16,
1550          0,                     /* rightshift */
1551          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1552          16,                    /* bitsize */
1553          FALSE,                 /* pc_relative */
1554          0,                     /* bitpos */
1555          complain_overflow_signed, /* complain_on_overflow */
1556          ppc64_elf_unhandled_reloc, /* special_function */
1557          "R_PPC64_TPREL16",     /* name */
1558          FALSE,                 /* partial_inplace */
1559          0,                     /* src_mask */
1560          0xffff,                /* dst_mask */
1561          FALSE),                /* pcrel_offset */
1562
1563   /* Like TPREL16, but no overflow.  */
1564   HOWTO (R_PPC64_TPREL16_LO,
1565          0,                     /* rightshift */
1566          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1567          16,                    /* bitsize */
1568          FALSE,                 /* pc_relative */
1569          0,                     /* bitpos */
1570          complain_overflow_dont, /* complain_on_overflow */
1571          ppc64_elf_unhandled_reloc, /* special_function */
1572          "R_PPC64_TPREL16_LO",  /* name */
1573          FALSE,                 /* partial_inplace */
1574          0,                     /* src_mask */
1575          0xffff,                /* dst_mask */
1576          FALSE),                /* pcrel_offset */
1577
1578   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1579   HOWTO (R_PPC64_TPREL16_HI,
1580          16,                    /* rightshift */
1581          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1582          16,                    /* bitsize */
1583          FALSE,                 /* pc_relative */
1584          0,                     /* bitpos */
1585          complain_overflow_signed, /* complain_on_overflow */
1586          ppc64_elf_unhandled_reloc, /* special_function */
1587          "R_PPC64_TPREL16_HI",  /* name */
1588          FALSE,                 /* partial_inplace */
1589          0,                     /* src_mask */
1590          0xffff,                /* dst_mask */
1591          FALSE),                /* pcrel_offset */
1592
1593   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1594   HOWTO (R_PPC64_TPREL16_HA,
1595          16,                    /* rightshift */
1596          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1597          16,                    /* bitsize */
1598          FALSE,                 /* pc_relative */
1599          0,                     /* bitpos */
1600          complain_overflow_signed, /* complain_on_overflow */
1601          ppc64_elf_unhandled_reloc, /* special_function */
1602          "R_PPC64_TPREL16_HA",  /* name */
1603          FALSE,                 /* partial_inplace */
1604          0,                     /* src_mask */
1605          0xffff,                /* dst_mask */
1606          FALSE),                /* pcrel_offset */
1607
1608   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1609   HOWTO (R_PPC64_TPREL16_HIGHER,
1610          32,                    /* rightshift */
1611          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1612          16,                    /* bitsize */
1613          FALSE,                 /* pc_relative */
1614          0,                     /* bitpos */
1615          complain_overflow_dont, /* complain_on_overflow */
1616          ppc64_elf_unhandled_reloc, /* special_function */
1617          "R_PPC64_TPREL16_HIGHER",      /* name */
1618          FALSE,                 /* partial_inplace */
1619          0,                     /* src_mask */
1620          0xffff,                /* dst_mask */
1621          FALSE),                /* pcrel_offset */
1622
1623   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1624   HOWTO (R_PPC64_TPREL16_HIGHERA,
1625          32,                    /* rightshift */
1626          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1627          16,                    /* bitsize */
1628          FALSE,                 /* pc_relative */
1629          0,                     /* bitpos */
1630          complain_overflow_dont, /* complain_on_overflow */
1631          ppc64_elf_unhandled_reloc, /* special_function */
1632          "R_PPC64_TPREL16_HIGHERA", /* name */
1633          FALSE,                 /* partial_inplace */
1634          0,                     /* src_mask */
1635          0xffff,                /* dst_mask */
1636          FALSE),                /* pcrel_offset */
1637
1638   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1639   HOWTO (R_PPC64_TPREL16_HIGHEST,
1640          48,                    /* rightshift */
1641          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1642          16,                    /* bitsize */
1643          FALSE,                 /* pc_relative */
1644          0,                     /* bitpos */
1645          complain_overflow_dont, /* complain_on_overflow */
1646          ppc64_elf_unhandled_reloc, /* special_function */
1647          "R_PPC64_TPREL16_HIGHEST", /* name */
1648          FALSE,                 /* partial_inplace */
1649          0,                     /* src_mask */
1650          0xffff,                /* dst_mask */
1651          FALSE),                /* pcrel_offset */
1652
1653   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1654   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1655          48,                    /* rightshift */
1656          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1657          16,                    /* bitsize */
1658          FALSE,                 /* pc_relative */
1659          0,                     /* bitpos */
1660          complain_overflow_dont, /* complain_on_overflow */
1661          ppc64_elf_unhandled_reloc, /* special_function */
1662          "R_PPC64_TPREL16_HIGHESTA", /* name */
1663          FALSE,                 /* partial_inplace */
1664          0,                     /* src_mask */
1665          0xffff,                /* dst_mask */
1666          FALSE),                /* pcrel_offset */
1667
1668   /* Like TPREL16, but for insns with a DS field.  */
1669   HOWTO (R_PPC64_TPREL16_DS,
1670          0,                     /* rightshift */
1671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1672          16,                    /* bitsize */
1673          FALSE,                 /* pc_relative */
1674          0,                     /* bitpos */
1675          complain_overflow_signed, /* complain_on_overflow */
1676          ppc64_elf_unhandled_reloc, /* special_function */
1677          "R_PPC64_TPREL16_DS",  /* name */
1678          FALSE,                 /* partial_inplace */
1679          0,                     /* src_mask */
1680          0xfffc,                /* dst_mask */
1681          FALSE),                /* pcrel_offset */
1682
1683   /* Like TPREL16_DS, but no overflow.  */
1684   HOWTO (R_PPC64_TPREL16_LO_DS,
1685          0,                     /* rightshift */
1686          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1687          16,                    /* bitsize */
1688          FALSE,                 /* pc_relative */
1689          0,                     /* bitpos */
1690          complain_overflow_dont, /* complain_on_overflow */
1691          ppc64_elf_unhandled_reloc, /* special_function */
1692          "R_PPC64_TPREL16_LO_DS", /* name */
1693          FALSE,                 /* partial_inplace */
1694          0,                     /* src_mask */
1695          0xfffc,                /* dst_mask */
1696          FALSE),                /* pcrel_offset */
1697
1698   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1699      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1700      to the first entry relative to the TOC base (r2).  */
1701   HOWTO (R_PPC64_GOT_TLSGD16,
1702          0,                     /* rightshift */
1703          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1704          16,                    /* bitsize */
1705          FALSE,                 /* pc_relative */
1706          0,                     /* bitpos */
1707          complain_overflow_signed, /* complain_on_overflow */
1708          ppc64_elf_unhandled_reloc, /* special_function */
1709          "R_PPC64_GOT_TLSGD16", /* name */
1710          FALSE,                 /* partial_inplace */
1711          0,                     /* src_mask */
1712          0xffff,                /* dst_mask */
1713          FALSE),                /* pcrel_offset */
1714
1715   /* Like GOT_TLSGD16, but no overflow.  */
1716   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1717          0,                     /* rightshift */
1718          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1719          16,                    /* bitsize */
1720          FALSE,                 /* pc_relative */
1721          0,                     /* bitpos */
1722          complain_overflow_dont, /* complain_on_overflow */
1723          ppc64_elf_unhandled_reloc, /* special_function */
1724          "R_PPC64_GOT_TLSGD16_LO", /* name */
1725          FALSE,                 /* partial_inplace */
1726          0,                     /* src_mask */
1727          0xffff,                /* dst_mask */
1728          FALSE),                /* pcrel_offset */
1729
1730   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1731   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1732          16,                    /* rightshift */
1733          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1734          16,                    /* bitsize */
1735          FALSE,                 /* pc_relative */
1736          0,                     /* bitpos */
1737          complain_overflow_signed, /* complain_on_overflow */
1738          ppc64_elf_unhandled_reloc, /* special_function */
1739          "R_PPC64_GOT_TLSGD16_HI", /* name */
1740          FALSE,                 /* partial_inplace */
1741          0,                     /* src_mask */
1742          0xffff,                /* dst_mask */
1743          FALSE),                /* pcrel_offset */
1744
1745   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1746   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1747          16,                    /* rightshift */
1748          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1749          16,                    /* bitsize */
1750          FALSE,                 /* pc_relative */
1751          0,                     /* bitpos */
1752          complain_overflow_signed, /* complain_on_overflow */
1753          ppc64_elf_unhandled_reloc, /* special_function */
1754          "R_PPC64_GOT_TLSGD16_HA", /* name */
1755          FALSE,                 /* partial_inplace */
1756          0,                     /* src_mask */
1757          0xffff,                /* dst_mask */
1758          FALSE),                /* pcrel_offset */
1759
1760   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1761      with values (sym+add)@dtpmod and zero, and computes the offset to the
1762      first entry relative to the TOC base (r2).  */
1763   HOWTO (R_PPC64_GOT_TLSLD16,
1764          0,                     /* rightshift */
1765          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1766          16,                    /* bitsize */
1767          FALSE,                 /* pc_relative */
1768          0,                     /* bitpos */
1769          complain_overflow_signed, /* complain_on_overflow */
1770          ppc64_elf_unhandled_reloc, /* special_function */
1771          "R_PPC64_GOT_TLSLD16", /* name */
1772          FALSE,                 /* partial_inplace */
1773          0,                     /* src_mask */
1774          0xffff,                /* dst_mask */
1775          FALSE),                /* pcrel_offset */
1776
1777   /* Like GOT_TLSLD16, but no overflow.  */
1778   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1779          0,                     /* rightshift */
1780          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1781          16,                    /* bitsize */
1782          FALSE,                 /* pc_relative */
1783          0,                     /* bitpos */
1784          complain_overflow_dont, /* complain_on_overflow */
1785          ppc64_elf_unhandled_reloc, /* special_function */
1786          "R_PPC64_GOT_TLSLD16_LO", /* name */
1787          FALSE,                 /* partial_inplace */
1788          0,                     /* src_mask */
1789          0xffff,                /* dst_mask */
1790          FALSE),                /* pcrel_offset */
1791
1792   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1793   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1794          16,                    /* rightshift */
1795          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1796          16,                    /* bitsize */
1797          FALSE,                 /* pc_relative */
1798          0,                     /* bitpos */
1799          complain_overflow_signed, /* complain_on_overflow */
1800          ppc64_elf_unhandled_reloc, /* special_function */
1801          "R_PPC64_GOT_TLSLD16_HI", /* name */
1802          FALSE,                 /* partial_inplace */
1803          0,                     /* src_mask */
1804          0xffff,                /* dst_mask */
1805          FALSE),                /* pcrel_offset */
1806
1807   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1808   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1809          16,                    /* rightshift */
1810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1811          16,                    /* bitsize */
1812          FALSE,                 /* pc_relative */
1813          0,                     /* bitpos */
1814          complain_overflow_signed, /* complain_on_overflow */
1815          ppc64_elf_unhandled_reloc, /* special_function */
1816          "R_PPC64_GOT_TLSLD16_HA", /* name */
1817          FALSE,                 /* partial_inplace */
1818          0,                     /* src_mask */
1819          0xffff,                /* dst_mask */
1820          FALSE),                /* pcrel_offset */
1821
1822   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1823      the offset to the entry relative to the TOC base (r2).  */
1824   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1825          0,                     /* rightshift */
1826          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1827          16,                    /* bitsize */
1828          FALSE,                 /* pc_relative */
1829          0,                     /* bitpos */
1830          complain_overflow_signed, /* complain_on_overflow */
1831          ppc64_elf_unhandled_reloc, /* special_function */
1832          "R_PPC64_GOT_DTPREL16_DS", /* name */
1833          FALSE,                 /* partial_inplace */
1834          0,                     /* src_mask */
1835          0xfffc,                /* dst_mask */
1836          FALSE),                /* pcrel_offset */
1837
1838   /* Like GOT_DTPREL16_DS, but no overflow.  */
1839   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1840          0,                     /* rightshift */
1841          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1842          16,                    /* bitsize */
1843          FALSE,                 /* pc_relative */
1844          0,                     /* bitpos */
1845          complain_overflow_dont, /* complain_on_overflow */
1846          ppc64_elf_unhandled_reloc, /* special_function */
1847          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1848          FALSE,                 /* partial_inplace */
1849          0,                     /* src_mask */
1850          0xfffc,                /* dst_mask */
1851          FALSE),                /* pcrel_offset */
1852
1853   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1854   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1855          16,                    /* rightshift */
1856          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1857          16,                    /* bitsize */
1858          FALSE,                 /* pc_relative */
1859          0,                     /* bitpos */
1860          complain_overflow_signed, /* complain_on_overflow */
1861          ppc64_elf_unhandled_reloc, /* special_function */
1862          "R_PPC64_GOT_DTPREL16_HI", /* name */
1863          FALSE,                 /* partial_inplace */
1864          0,                     /* src_mask */
1865          0xffff,                /* dst_mask */
1866          FALSE),                /* pcrel_offset */
1867
1868   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1869   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1870          16,                    /* rightshift */
1871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1872          16,                    /* bitsize */
1873          FALSE,                 /* pc_relative */
1874          0,                     /* bitpos */
1875          complain_overflow_signed, /* complain_on_overflow */
1876          ppc64_elf_unhandled_reloc, /* special_function */
1877          "R_PPC64_GOT_DTPREL16_HA", /* name */
1878          FALSE,                 /* partial_inplace */
1879          0,                     /* src_mask */
1880          0xffff,                /* dst_mask */
1881          FALSE),                /* pcrel_offset */
1882
1883   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1884      offset to the entry relative to the TOC base (r2).  */
1885   HOWTO (R_PPC64_GOT_TPREL16_DS,
1886          0,                     /* rightshift */
1887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1888          16,                    /* bitsize */
1889          FALSE,                 /* pc_relative */
1890          0,                     /* bitpos */
1891          complain_overflow_signed, /* complain_on_overflow */
1892          ppc64_elf_unhandled_reloc, /* special_function */
1893          "R_PPC64_GOT_TPREL16_DS", /* name */
1894          FALSE,                 /* partial_inplace */
1895          0,                     /* src_mask */
1896          0xfffc,                /* dst_mask */
1897          FALSE),                /* pcrel_offset */
1898
1899   /* Like GOT_TPREL16_DS, but no overflow.  */
1900   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1901          0,                     /* rightshift */
1902          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1903          16,                    /* bitsize */
1904          FALSE,                 /* pc_relative */
1905          0,                     /* bitpos */
1906          complain_overflow_dont, /* complain_on_overflow */
1907          ppc64_elf_unhandled_reloc, /* special_function */
1908          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1909          FALSE,                 /* partial_inplace */
1910          0,                     /* src_mask */
1911          0xfffc,                /* dst_mask */
1912          FALSE),                /* pcrel_offset */
1913
1914   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1915   HOWTO (R_PPC64_GOT_TPREL16_HI,
1916          16,                    /* rightshift */
1917          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1918          16,                    /* bitsize */
1919          FALSE,                 /* pc_relative */
1920          0,                     /* bitpos */
1921          complain_overflow_signed, /* complain_on_overflow */
1922          ppc64_elf_unhandled_reloc, /* special_function */
1923          "R_PPC64_GOT_TPREL16_HI", /* name */
1924          FALSE,                 /* partial_inplace */
1925          0,                     /* src_mask */
1926          0xffff,                /* dst_mask */
1927          FALSE),                /* pcrel_offset */
1928
1929   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1930   HOWTO (R_PPC64_GOT_TPREL16_HA,
1931          16,                    /* rightshift */
1932          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1933          16,                    /* bitsize */
1934          FALSE,                 /* pc_relative */
1935          0,                     /* bitpos */
1936          complain_overflow_signed, /* complain_on_overflow */
1937          ppc64_elf_unhandled_reloc, /* special_function */
1938          "R_PPC64_GOT_TPREL16_HA", /* name */
1939          FALSE,                 /* partial_inplace */
1940          0,                     /* src_mask */
1941          0xffff,                /* dst_mask */
1942          FALSE),                /* pcrel_offset */
1943
1944   HOWTO (R_PPC64_JMP_IREL,      /* type */
1945          0,                     /* rightshift */
1946          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947          0,                     /* bitsize */
1948          FALSE,                 /* pc_relative */
1949          0,                     /* bitpos */
1950          complain_overflow_dont, /* complain_on_overflow */
1951          ppc64_elf_unhandled_reloc, /* special_function */
1952          "R_PPC64_JMP_IREL",    /* name */
1953          FALSE,                 /* partial_inplace */
1954          0,                     /* src_mask */
1955          0,                     /* dst_mask */
1956          FALSE),                /* pcrel_offset */
1957
1958   HOWTO (R_PPC64_IRELATIVE,     /* type */
1959          0,                     /* rightshift */
1960          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1961          64,                    /* bitsize */
1962          FALSE,                 /* pc_relative */
1963          0,                     /* bitpos */
1964          complain_overflow_dont, /* complain_on_overflow */
1965          bfd_elf_generic_reloc, /* special_function */
1966          "R_PPC64_IRELATIVE",   /* name */
1967          FALSE,                 /* partial_inplace */
1968          0,                     /* src_mask */
1969          ONES (64),             /* dst_mask */
1970          FALSE),                /* pcrel_offset */
1971
1972   /* A 16 bit relative relocation.  */
1973   HOWTO (R_PPC64_REL16,         /* type */
1974          0,                     /* rightshift */
1975          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1976          16,                    /* bitsize */
1977          TRUE,                  /* pc_relative */
1978          0,                     /* bitpos */
1979          complain_overflow_signed, /* complain_on_overflow */
1980          bfd_elf_generic_reloc, /* special_function */
1981          "R_PPC64_REL16",       /* name */
1982          FALSE,                 /* partial_inplace */
1983          0,                     /* src_mask */
1984          0xffff,                /* dst_mask */
1985          TRUE),                 /* pcrel_offset */
1986
1987   /* A 16 bit relative relocation without overflow.  */
1988   HOWTO (R_PPC64_REL16_LO,      /* type */
1989          0,                     /* rightshift */
1990          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1991          16,                    /* bitsize */
1992          TRUE,                  /* pc_relative */
1993          0,                     /* bitpos */
1994          complain_overflow_dont,/* complain_on_overflow */
1995          bfd_elf_generic_reloc, /* special_function */
1996          "R_PPC64_REL16_LO",    /* name */
1997          FALSE,                 /* partial_inplace */
1998          0,                     /* src_mask */
1999          0xffff,                /* dst_mask */
2000          TRUE),                 /* pcrel_offset */
2001
2002   /* The high order 16 bits of a relative address.  */
2003   HOWTO (R_PPC64_REL16_HI,      /* type */
2004          16,                    /* rightshift */
2005          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2006          16,                    /* bitsize */
2007          TRUE,                  /* pc_relative */
2008          0,                     /* bitpos */
2009          complain_overflow_signed, /* complain_on_overflow */
2010          bfd_elf_generic_reloc, /* special_function */
2011          "R_PPC64_REL16_HI",    /* name */
2012          FALSE,                 /* partial_inplace */
2013          0,                     /* src_mask */
2014          0xffff,                /* dst_mask */
2015          TRUE),                 /* pcrel_offset */
2016
2017   /* The high order 16 bits of a relative address, plus 1 if the contents of
2018      the low 16 bits, treated as a signed number, is negative.  */
2019   HOWTO (R_PPC64_REL16_HA,      /* type */
2020          16,                    /* rightshift */
2021          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2022          16,                    /* bitsize */
2023          TRUE,                  /* pc_relative */
2024          0,                     /* bitpos */
2025          complain_overflow_signed, /* complain_on_overflow */
2026          ppc64_elf_ha_reloc,    /* special_function */
2027          "R_PPC64_REL16_HA",    /* name */
2028          FALSE,                 /* partial_inplace */
2029          0,                     /* src_mask */
2030          0xffff,                /* dst_mask */
2031          TRUE),                 /* pcrel_offset */
2032
2033   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2034   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2035          16,                    /* rightshift */
2036          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2037          16,                    /* bitsize */
2038          TRUE,                  /* pc_relative */
2039          0,                     /* bitpos */
2040          complain_overflow_signed, /* complain_on_overflow */
2041          ppc64_elf_ha_reloc,    /* special_function */
2042          "R_PPC64_REL16DX_HA",  /* name */
2043          FALSE,                 /* partial_inplace */
2044          0,                     /* src_mask */
2045          0x1fffc1,              /* dst_mask */
2046          TRUE),                 /* pcrel_offset */
2047
2048   /* A split-field reloc for addpcis, non-relative (gas internal use only).  */
2049   HOWTO (R_PPC64_16DX_HA,       /* type */
2050          16,                    /* rightshift */
2051          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2052          16,                    /* bitsize */
2053          FALSE,                 /* pc_relative */
2054          0,                     /* bitpos */
2055          complain_overflow_signed, /* complain_on_overflow */
2056          ppc64_elf_ha_reloc,    /* special_function */
2057          "R_PPC64_16DX_HA",     /* name */
2058          FALSE,                 /* partial_inplace */
2059          0,                     /* src_mask */
2060          0x1fffc1,              /* dst_mask */
2061          FALSE),                /* pcrel_offset */
2062
2063   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2064   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2065          16,                    /* rightshift */
2066          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2067          16,                    /* bitsize */
2068          FALSE,                 /* pc_relative */
2069          0,                     /* bitpos */
2070          complain_overflow_dont, /* complain_on_overflow */
2071          bfd_elf_generic_reloc, /* special_function */
2072          "R_PPC64_ADDR16_HIGH", /* name */
2073          FALSE,                 /* partial_inplace */
2074          0,                     /* src_mask */
2075          0xffff,                /* dst_mask */
2076          FALSE),                /* pcrel_offset */
2077
2078   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2079   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2080          16,                    /* rightshift */
2081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2082          16,                    /* bitsize */
2083          FALSE,                 /* pc_relative */
2084          0,                     /* bitpos */
2085          complain_overflow_dont, /* complain_on_overflow */
2086          ppc64_elf_ha_reloc,    /* special_function */
2087          "R_PPC64_ADDR16_HIGHA",        /* name */
2088          FALSE,                 /* partial_inplace */
2089          0,                     /* src_mask */
2090          0xffff,                /* dst_mask */
2091          FALSE),                /* pcrel_offset */
2092
2093   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2094   HOWTO (R_PPC64_DTPREL16_HIGH,
2095          16,                    /* rightshift */
2096          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2097          16,                    /* bitsize */
2098          FALSE,                 /* pc_relative */
2099          0,                     /* bitpos */
2100          complain_overflow_dont, /* complain_on_overflow */
2101          ppc64_elf_unhandled_reloc, /* special_function */
2102          "R_PPC64_DTPREL16_HIGH", /* name */
2103          FALSE,                 /* partial_inplace */
2104          0,                     /* src_mask */
2105          0xffff,                /* dst_mask */
2106          FALSE),                /* pcrel_offset */
2107
2108   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2109   HOWTO (R_PPC64_DTPREL16_HIGHA,
2110          16,                    /* rightshift */
2111          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2112          16,                    /* bitsize */
2113          FALSE,                 /* pc_relative */
2114          0,                     /* bitpos */
2115          complain_overflow_dont, /* complain_on_overflow */
2116          ppc64_elf_unhandled_reloc, /* special_function */
2117          "R_PPC64_DTPREL16_HIGHA", /* name */
2118          FALSE,                 /* partial_inplace */
2119          0,                     /* src_mask */
2120          0xffff,                /* dst_mask */
2121          FALSE),                /* pcrel_offset */
2122
2123   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2124   HOWTO (R_PPC64_TPREL16_HIGH,
2125          16,                    /* rightshift */
2126          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2127          16,                    /* bitsize */
2128          FALSE,                 /* pc_relative */
2129          0,                     /* bitpos */
2130          complain_overflow_dont, /* complain_on_overflow */
2131          ppc64_elf_unhandled_reloc, /* special_function */
2132          "R_PPC64_TPREL16_HIGH",        /* name */
2133          FALSE,                 /* partial_inplace */
2134          0,                     /* src_mask */
2135          0xffff,                /* dst_mask */
2136          FALSE),                /* pcrel_offset */
2137
2138   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2139   HOWTO (R_PPC64_TPREL16_HIGHA,
2140          16,                    /* rightshift */
2141          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2142          16,                    /* bitsize */
2143          FALSE,                 /* pc_relative */
2144          0,                     /* bitpos */
2145          complain_overflow_dont, /* complain_on_overflow */
2146          ppc64_elf_unhandled_reloc, /* special_function */
2147          "R_PPC64_TPREL16_HIGHA",       /* name */
2148          FALSE,                 /* partial_inplace */
2149          0,                     /* src_mask */
2150          0xffff,                /* dst_mask */
2151          FALSE),                /* pcrel_offset */
2152
2153   /* Marker reloc on ELFv2 large-model function entry.  */
2154   HOWTO (R_PPC64_ENTRY,
2155          0,                     /* rightshift */
2156          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2157          32,                    /* bitsize */
2158          FALSE,                 /* pc_relative */
2159          0,                     /* bitpos */
2160          complain_overflow_dont, /* complain_on_overflow */
2161          bfd_elf_generic_reloc, /* special_function */
2162          "R_PPC64_ENTRY",       /* name */
2163          FALSE,                 /* partial_inplace */
2164          0,                     /* src_mask */
2165          0,                     /* dst_mask */
2166          FALSE),                /* pcrel_offset */
2167
2168   /* Like ADDR64, but use local entry point of function.  */
2169   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2170          0,                     /* rightshift */
2171          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2172          64,                    /* bitsize */
2173          FALSE,                 /* pc_relative */
2174          0,                     /* bitpos */
2175          complain_overflow_dont, /* complain_on_overflow */
2176          bfd_elf_generic_reloc, /* special_function */
2177          "R_PPC64_ADDR64_LOCAL", /* name */
2178          FALSE,                 /* partial_inplace */
2179          0,                     /* src_mask */
2180          ONES (64),             /* dst_mask */
2181          FALSE),                /* pcrel_offset */
2182
2183   /* GNU extension to record C++ vtable hierarchy.  */
2184   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2185          0,                     /* rightshift */
2186          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2187          0,                     /* bitsize */
2188          FALSE,                 /* pc_relative */
2189          0,                     /* bitpos */
2190          complain_overflow_dont, /* complain_on_overflow */
2191          NULL,                  /* special_function */
2192          "R_PPC64_GNU_VTINHERIT", /* name */
2193          FALSE,                 /* partial_inplace */
2194          0,                     /* src_mask */
2195          0,                     /* dst_mask */
2196          FALSE),                /* pcrel_offset */
2197
2198   /* GNU extension to record C++ vtable member usage.  */
2199   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2200          0,                     /* rightshift */
2201          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2202          0,                     /* bitsize */
2203          FALSE,                 /* pc_relative */
2204          0,                     /* bitpos */
2205          complain_overflow_dont, /* complain_on_overflow */
2206          NULL,                  /* special_function */
2207          "R_PPC64_GNU_VTENTRY", /* name */
2208          FALSE,                 /* partial_inplace */
2209          0,                     /* src_mask */
2210          0,                     /* dst_mask */
2211          FALSE),                /* pcrel_offset */
2212 };
2213
2214 \f
2215 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2216    be done.  */
2217
2218 static void
2219 ppc_howto_init (void)
2220 {
2221   unsigned int i, type;
2222
2223   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2224     {
2225       type = ppc64_elf_howto_raw[i].type;
2226       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2227       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2228     }
2229 }
2230
2231 static reloc_howto_type *
2232 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2233                              bfd_reloc_code_real_type code)
2234 {
2235   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2236
2237   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2238     /* Initialize howto table if needed.  */
2239     ppc_howto_init ();
2240
2241   switch (code)
2242     {
2243     default:
2244       return NULL;
2245
2246     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2247       break;
2248     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2249       break;
2250     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2251       break;
2252     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2253       break;
2254     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2255       break;
2256     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2257       break;
2258     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2259       break;
2260     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2261       break;
2262     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2263       break;
2264     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2265       break;
2266     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2267       break;
2268     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2269       break;
2270     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2271       break;
2272     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2273       break;
2274     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2275       break;
2276     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2277       break;
2278     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2279       break;
2280     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2281       break;
2282     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2283       break;
2284     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2285       break;
2286     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2287       break;
2288     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2289       break;
2290     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2291       break;
2292     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2293       break;
2294     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2295       break;
2296     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2297       break;
2298     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2299       break;
2300     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2301       break;
2302     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2303       break;
2304     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2305       break;
2306     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2307       break;
2308     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2309       break;
2310     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2311       break;
2312     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2313       break;
2314     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2315       break;
2316     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2317       break;
2318     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2319       break;
2320     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2321       break;
2322     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2323       break;
2324     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2325       break;
2326     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2327       break;
2328     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2329       break;
2330     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2331       break;
2332     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2333       break;
2334     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2335       break;
2336     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2337       break;
2338     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2339       break;
2340     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2341       break;
2342     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2343       break;
2344     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2345       break;
2346     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2347       break;
2348     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2351       break;
2352     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2353       break;
2354     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2355       break;
2356     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2357       break;
2358     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2359       break;
2360     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2361       break;
2362     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2363       break;
2364     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2365       break;
2366     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2367       break;
2368     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2369       break;
2370     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2371       break;
2372     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2373       break;
2374     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2375       break;
2376     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2377       break;
2378     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2379       break;
2380     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2383       break;
2384     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2387       break;
2388     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2389       break;
2390     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2391       break;
2392     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2393       break;
2394     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2397       break;
2398     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2401       break;
2402     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2403       break;
2404     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2405       break;
2406     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2407       break;
2408     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2409       break;
2410     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2411       break;
2412     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2413       break;
2414     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2415       break;
2416     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2417       break;
2418     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2419       break;
2420     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2421       break;
2422     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2423       break;
2424     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2425       break;
2426     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2427       break;
2428     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2429       break;
2430     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2431       break;
2432     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2433       break;
2434     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2435       break;
2436     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2437       break;
2438     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2439       break;
2440     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2441       break;
2442     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2443       break;
2444     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2445       break;
2446     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2447       break;
2448     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2449       break;
2450     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2451       break;
2452     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2453       break;
2454     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2455       break;
2456     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2457       break;
2458     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2459       break;
2460     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2461       break;
2462     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2463       break;
2464     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2465       break;
2466     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2467       break;
2468     case BFD_RELOC_PPC_16DX_HA:                 r = R_PPC64_16DX_HA;
2469       break;
2470     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2471       break;
2472     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2473       break;
2474     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2475       break;
2476     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2477       break;
2478     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2479       break;
2480     }
2481
2482   return ppc64_elf_howto_table[r];
2483 };
2484
2485 static reloc_howto_type *
2486 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2487                              const char *r_name)
2488 {
2489   unsigned int i;
2490
2491   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2492     if (ppc64_elf_howto_raw[i].name != NULL
2493         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2494       return &ppc64_elf_howto_raw[i];
2495
2496   return NULL;
2497 }
2498
2499 /* Set the howto pointer for a PowerPC ELF reloc.  */
2500
2501 static void
2502 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2503                          Elf_Internal_Rela *dst)
2504 {
2505   unsigned int type;
2506
2507   /* Initialize howto table if needed.  */
2508   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2509     ppc_howto_init ();
2510
2511   type = ELF64_R_TYPE (dst->r_info);
2512   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2513     {
2514       /* xgettext:c-format */
2515       _bfd_error_handler (_("%B: invalid relocation type %d"),
2516                           abfd, (int) type);
2517       type = R_PPC64_NONE;
2518     }
2519   cache_ptr->howto = ppc64_elf_howto_table[type];
2520 }
2521
2522 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2523
2524 static bfd_reloc_status_type
2525 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526                     void *data, asection *input_section,
2527                     bfd *output_bfd, char **error_message)
2528 {
2529   enum elf_ppc64_reloc_type r_type;
2530   long insn;
2531   bfd_size_type octets;
2532   bfd_vma value;
2533
2534   /* If this is a relocatable link (output_bfd test tells us), just
2535      call the generic function.  Any adjustment will be done at final
2536      link time.  */
2537   if (output_bfd != NULL)
2538     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2539                                   input_section, output_bfd, error_message);
2540
2541   /* Adjust the addend for sign extension of the low 16 bits.
2542      We won't actually be using the low 16 bits, so trashing them
2543      doesn't matter.  */
2544   reloc_entry->addend += 0x8000;
2545   r_type = reloc_entry->howto->type;
2546   if (r_type != R_PPC64_REL16DX_HA)
2547     return bfd_reloc_continue;
2548
2549   value = 0;
2550   if (!bfd_is_com_section (symbol->section))
2551     value = symbol->value;
2552   value += (reloc_entry->addend
2553             + symbol->section->output_offset
2554             + symbol->section->output_section->vma);
2555   value -= (reloc_entry->address
2556             + input_section->output_offset
2557             + input_section->output_section->vma);
2558   value = (bfd_signed_vma) value >> 16;
2559
2560   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2561   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2562   insn &= ~0x1fffc1;
2563   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2564   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2565   if (value + 0x8000 > 0xffff)
2566     return bfd_reloc_overflow;
2567   return bfd_reloc_ok;
2568 }
2569
2570 static bfd_reloc_status_type
2571 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2572                         void *data, asection *input_section,
2573                         bfd *output_bfd, char **error_message)
2574 {
2575   if (output_bfd != NULL)
2576     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2577                                   input_section, output_bfd, error_message);
2578
2579   if (strcmp (symbol->section->name, ".opd") == 0
2580       && (symbol->section->owner->flags & DYNAMIC) == 0)
2581     {
2582       bfd_vma dest = opd_entry_value (symbol->section,
2583                                       symbol->value + reloc_entry->addend,
2584                                       NULL, NULL, FALSE);
2585       if (dest != (bfd_vma) -1)
2586         reloc_entry->addend = dest - (symbol->value
2587                                       + symbol->section->output_section->vma
2588                                       + symbol->section->output_offset);
2589     }
2590   else
2591     {
2592       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2593
2594       if (symbol->section->owner != abfd
2595           && symbol->section->owner != NULL
2596           && abiversion (symbol->section->owner) >= 2)
2597         {
2598           unsigned int i;
2599
2600           for (i = 0; i < symbol->section->owner->symcount; ++i)
2601             {
2602               asymbol *symdef = symbol->section->owner->outsymbols[i];
2603
2604               if (strcmp (symdef->name, symbol->name) == 0)
2605                 {
2606                   elfsym = (elf_symbol_type *) symdef;
2607                   break;
2608                 }
2609             }
2610         }
2611       reloc_entry->addend
2612         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2613     }
2614   return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619                          void *data, asection *input_section,
2620                          bfd *output_bfd, char **error_message)
2621 {
2622   long insn;
2623   enum elf_ppc64_reloc_type r_type;
2624   bfd_size_type octets;
2625   /* Assume 'at' branch hints.  */
2626   bfd_boolean is_isa_v2 = TRUE;
2627
2628   /* If this is a relocatable link (output_bfd test tells us), just
2629      call the generic function.  Any adjustment will be done at final
2630      link time.  */
2631   if (output_bfd != NULL)
2632     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2633                                   input_section, output_bfd, error_message);
2634
2635   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2636   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2637   insn &= ~(0x01 << 21);
2638   r_type = reloc_entry->howto->type;
2639   if (r_type == R_PPC64_ADDR14_BRTAKEN
2640       || r_type == R_PPC64_REL14_BRTAKEN)
2641     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2642
2643   if (is_isa_v2)
2644     {
2645       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2646          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2647          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2648       if ((insn & (0x14 << 21)) == (0x04 << 21))
2649         insn |= 0x02 << 21;
2650       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2651         insn |= 0x08 << 21;
2652       else
2653         goto out;
2654     }
2655   else
2656     {
2657       bfd_vma target = 0;
2658       bfd_vma from;
2659
2660       if (!bfd_is_com_section (symbol->section))
2661         target = symbol->value;
2662       target += symbol->section->output_section->vma;
2663       target += symbol->section->output_offset;
2664       target += reloc_entry->addend;
2665
2666       from = (reloc_entry->address
2667               + input_section->output_offset
2668               + input_section->output_section->vma);
2669
2670       /* Invert 'y' bit if not the default.  */
2671       if ((bfd_signed_vma) (target - from) < 0)
2672         insn ^= 0x01 << 21;
2673     }
2674   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2675  out:
2676   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2677                                  input_section, output_bfd, error_message);
2678 }
2679
2680 static bfd_reloc_status_type
2681 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2682                          void *data, asection *input_section,
2683                          bfd *output_bfd, char **error_message)
2684 {
2685   /* If this is a relocatable link (output_bfd test tells us), just
2686      call the generic function.  Any adjustment will be done at final
2687      link time.  */
2688   if (output_bfd != NULL)
2689     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2690                                   input_section, output_bfd, error_message);
2691
2692   /* Subtract the symbol section base address.  */
2693   reloc_entry->addend -= symbol->section->output_section->vma;
2694   return bfd_reloc_continue;
2695 }
2696
2697 static bfd_reloc_status_type
2698 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699                             void *data, asection *input_section,
2700                             bfd *output_bfd, char **error_message)
2701 {
2702   /* If this is a relocatable link (output_bfd test tells us), just
2703      call the generic function.  Any adjustment will be done at final
2704      link time.  */
2705   if (output_bfd != NULL)
2706     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707                                   input_section, output_bfd, error_message);
2708
2709   /* Subtract the symbol section base address.  */
2710   reloc_entry->addend -= symbol->section->output_section->vma;
2711
2712   /* Adjust the addend for sign extension of the low 16 bits.  */
2713   reloc_entry->addend += 0x8000;
2714   return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719                      void *data, asection *input_section,
2720                      bfd *output_bfd, char **error_message)
2721 {
2722   bfd_vma TOCstart;
2723
2724   /* If this is a relocatable link (output_bfd test tells us), just
2725      call the generic function.  Any adjustment will be done at final
2726      link time.  */
2727   if (output_bfd != NULL)
2728     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729                                   input_section, output_bfd, error_message);
2730
2731   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732   if (TOCstart == 0)
2733     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735   /* Subtract the TOC base address.  */
2736   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737   return bfd_reloc_continue;
2738 }
2739
2740 static bfd_reloc_status_type
2741 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2742                         void *data, asection *input_section,
2743                         bfd *output_bfd, char **error_message)
2744 {
2745   bfd_vma TOCstart;
2746
2747   /* If this is a relocatable link (output_bfd test tells us), just
2748      call the generic function.  Any adjustment will be done at final
2749      link time.  */
2750   if (output_bfd != NULL)
2751     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2752                                   input_section, output_bfd, error_message);
2753
2754   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2755   if (TOCstart == 0)
2756     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2757
2758   /* Subtract the TOC base address.  */
2759   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2760
2761   /* Adjust the addend for sign extension of the low 16 bits.  */
2762   reloc_entry->addend += 0x8000;
2763   return bfd_reloc_continue;
2764 }
2765
2766 static bfd_reloc_status_type
2767 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2768                        void *data, asection *input_section,
2769                        bfd *output_bfd, char **error_message)
2770 {
2771   bfd_vma TOCstart;
2772   bfd_size_type octets;
2773
2774   /* If this is a relocatable link (output_bfd test tells us), just
2775      call the generic function.  Any adjustment will be done at final
2776      link time.  */
2777   if (output_bfd != NULL)
2778     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779                                   input_section, output_bfd, error_message);
2780
2781   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2782   if (TOCstart == 0)
2783     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2784
2785   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2786   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2787   return bfd_reloc_ok;
2788 }
2789
2790 static bfd_reloc_status_type
2791 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2792                            void *data, asection *input_section,
2793                            bfd *output_bfd, char **error_message)
2794 {
2795   /* If this is a relocatable link (output_bfd test tells us), just
2796      call the generic function.  Any adjustment will be done at final
2797      link time.  */
2798   if (output_bfd != NULL)
2799     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2800                                   input_section, output_bfd, error_message);
2801
2802   if (error_message != NULL)
2803     {
2804       static char buf[60];
2805       sprintf (buf, "generic linker can't handle %s",
2806                reloc_entry->howto->name);
2807       *error_message = buf;
2808     }
2809   return bfd_reloc_dangerous;
2810 }
2811
2812 /* Track GOT entries needed for a given symbol.  We might need more
2813    than one got entry per symbol.  */
2814 struct got_entry
2815 {
2816   struct got_entry *next;
2817
2818   /* The symbol addend that we'll be placing in the GOT.  */
2819   bfd_vma addend;
2820
2821   /* Unlike other ELF targets, we use separate GOT entries for the same
2822      symbol referenced from different input files.  This is to support
2823      automatic multiple TOC/GOT sections, where the TOC base can vary
2824      from one input file to another.  After partitioning into TOC groups
2825      we merge entries within the group.
2826
2827      Point to the BFD owning this GOT entry.  */
2828   bfd *owner;
2829
2830   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2831      TLS_TPREL or TLS_DTPREL for tls entries.  */
2832   unsigned char tls_type;
2833
2834   /* Non-zero if got.ent points to real entry.  */
2835   unsigned char is_indirect;
2836
2837   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2838   union
2839     {
2840       bfd_signed_vma refcount;
2841       bfd_vma offset;
2842       struct got_entry *ent;
2843     } got;
2844 };
2845
2846 /* The same for PLT.  */
2847 struct plt_entry
2848 {
2849   struct plt_entry *next;
2850
2851   bfd_vma addend;
2852
2853   union
2854     {
2855       bfd_signed_vma refcount;
2856       bfd_vma offset;
2857     } plt;
2858 };
2859
2860 struct ppc64_elf_obj_tdata
2861 {
2862   struct elf_obj_tdata elf;
2863
2864   /* Shortcuts to dynamic linker sections.  */
2865   asection *got;
2866   asection *relgot;
2867
2868   /* Used during garbage collection.  We attach global symbols defined
2869      on removed .opd entries to this section so that the sym is removed.  */
2870   asection *deleted_section;
2871
2872   /* TLS local dynamic got entry handling.  Support for multiple GOT
2873      sections means we potentially need one of these for each input bfd.  */
2874   struct got_entry tlsld_got;
2875
2876   union {
2877     /* A copy of relocs before they are modified for --emit-relocs.  */
2878     Elf_Internal_Rela *relocs;
2879
2880     /* Section contents.  */
2881     bfd_byte *contents;
2882   } opd;
2883
2884   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2885      the reloc to be in the range -32768 to 32767.  */
2886   unsigned int has_small_toc_reloc : 1;
2887
2888   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2889      instruction not one we handle.  */
2890   unsigned int unexpected_toc_insn : 1;
2891 };
2892
2893 #define ppc64_elf_tdata(bfd) \
2894   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2895
2896 #define ppc64_tlsld_got(bfd) \
2897   (&ppc64_elf_tdata (bfd)->tlsld_got)
2898
2899 #define is_ppc64_elf(bfd) \
2900   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2901    && elf_object_id (bfd) == PPC64_ELF_DATA)
2902
2903 /* Override the generic function because we store some extras.  */
2904
2905 static bfd_boolean
2906 ppc64_elf_mkobject (bfd *abfd)
2907 {
2908   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2909                                   PPC64_ELF_DATA);
2910 }
2911
2912 /* Fix bad default arch selected for a 64 bit input bfd when the
2913    default is 32 bit.  Also select arch based on apuinfo.  */
2914
2915 static bfd_boolean
2916 ppc64_elf_object_p (bfd *abfd)
2917 {
2918   if (!abfd->arch_info->the_default)
2919     return TRUE;
2920
2921   if (abfd->arch_info->bits_per_word == 32)
2922     {
2923       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2924
2925       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2926         {
2927           /* Relies on arch after 32 bit default being 64 bit default.  */
2928           abfd->arch_info = abfd->arch_info->next;
2929           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2930         }
2931     }
2932   return _bfd_elf_ppc_set_arch (abfd);
2933 }
2934
2935 /* Support for core dump NOTE sections.  */
2936
2937 static bfd_boolean
2938 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2939 {
2940   size_t offset, size;
2941
2942   if (note->descsz != 504)
2943     return FALSE;
2944
2945   /* pr_cursig */
2946   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2947
2948   /* pr_pid */
2949   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2950
2951   /* pr_reg */
2952   offset = 112;
2953   size = 384;
2954
2955   /* Make a ".reg/999" section.  */
2956   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2957                                           size, note->descpos + offset);
2958 }
2959
2960 static bfd_boolean
2961 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2962 {
2963   if (note->descsz != 136)
2964     return FALSE;
2965
2966   elf_tdata (abfd)->core->pid
2967     = bfd_get_32 (abfd, note->descdata + 24);
2968   elf_tdata (abfd)->core->program
2969     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2970   elf_tdata (abfd)->core->command
2971     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2972
2973   return TRUE;
2974 }
2975
2976 static char *
2977 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2978                            ...)
2979 {
2980   switch (note_type)
2981     {
2982     default:
2983       return NULL;
2984
2985     case NT_PRPSINFO:
2986       {
2987         char data[136];
2988         va_list ap;
2989
2990         va_start (ap, note_type);
2991         memset (data, 0, sizeof (data));
2992         strncpy (data + 40, va_arg (ap, const char *), 16);
2993         strncpy (data + 56, va_arg (ap, const char *), 80);
2994         va_end (ap);
2995         return elfcore_write_note (abfd, buf, bufsiz,
2996                                    "CORE", note_type, data, sizeof (data));
2997       }
2998
2999     case NT_PRSTATUS:
3000       {
3001         char data[504];
3002         va_list ap;
3003         long pid;
3004         int cursig;
3005         const void *greg;
3006
3007         va_start (ap, note_type);
3008         memset (data, 0, 112);
3009         pid = va_arg (ap, long);
3010         bfd_put_32 (abfd, pid, data + 32);
3011         cursig = va_arg (ap, int);
3012         bfd_put_16 (abfd, cursig, data + 12);
3013         greg = va_arg (ap, const void *);
3014         memcpy (data + 112, greg, 384);
3015         memset (data + 496, 0, 8);
3016         va_end (ap);
3017         return elfcore_write_note (abfd, buf, bufsiz,
3018                                    "CORE", note_type, data, sizeof (data));
3019       }
3020     }
3021 }
3022
3023 /* Add extra PPC sections.  */
3024
3025 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3026 {
3027   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3028   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3029   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3030   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3033   { NULL,                     0,  0, 0,            0 }
3034 };
3035
3036 enum _ppc64_sec_type {
3037   sec_normal = 0,
3038   sec_opd = 1,
3039   sec_toc = 2
3040 };
3041
3042 struct _ppc64_elf_section_data
3043 {
3044   struct bfd_elf_section_data elf;
3045
3046   union
3047   {
3048     /* An array with one entry for each opd function descriptor,
3049        and some spares since opd entries may be either 16 or 24 bytes.  */
3050 #define OPD_NDX(OFF) ((OFF) >> 4)
3051     struct _opd_sec_data
3052     {
3053       /* Points to the function code section for local opd entries.  */
3054       asection **func_sec;
3055
3056       /* After editing .opd, adjust references to opd local syms.  */
3057       long *adjust;
3058     } opd;
3059
3060     /* An array for toc sections, indexed by offset/8.  */
3061     struct _toc_sec_data
3062     {
3063       /* Specifies the relocation symbol index used at a given toc offset.  */
3064       unsigned *symndx;
3065
3066       /* And the relocation addend.  */
3067       bfd_vma *add;
3068     } toc;
3069   } u;
3070
3071   enum _ppc64_sec_type sec_type:2;
3072
3073   /* Flag set when small branches are detected.  Used to
3074      select suitable defaults for the stub group size.  */
3075   unsigned int has_14bit_branch:1;
3076 };
3077
3078 #define ppc64_elf_section_data(sec) \
3079   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3080
3081 static bfd_boolean
3082 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3083 {
3084   if (!sec->used_by_bfd)
3085     {
3086       struct _ppc64_elf_section_data *sdata;
3087       bfd_size_type amt = sizeof (*sdata);
3088
3089       sdata = bfd_zalloc (abfd, amt);
3090       if (sdata == NULL)
3091         return FALSE;
3092       sec->used_by_bfd = sdata;
3093     }
3094
3095   return _bfd_elf_new_section_hook (abfd, sec);
3096 }
3097
3098 static struct _opd_sec_data *
3099 get_opd_info (asection * sec)
3100 {
3101   if (sec != NULL
3102       && ppc64_elf_section_data (sec) != NULL
3103       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3104     return &ppc64_elf_section_data (sec)->u.opd;
3105   return NULL;
3106 }
3107 \f
3108 /* Parameters for the qsort hook.  */
3109 static bfd_boolean synthetic_relocatable;
3110 static asection *synthetic_opd;
3111
3112 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3113
3114 static int
3115 compare_symbols (const void *ap, const void *bp)
3116 {
3117   const asymbol *a = * (const asymbol **) ap;
3118   const asymbol *b = * (const asymbol **) bp;
3119
3120   /* Section symbols first.  */
3121   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3122     return -1;
3123   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3124     return 1;
3125
3126   /* then .opd symbols.  */
3127   if (synthetic_opd != NULL)
3128     {
3129       if (strcmp (a->section->name, ".opd") == 0
3130           && strcmp (b->section->name, ".opd") != 0)
3131         return -1;
3132       if (strcmp (a->section->name, ".opd") != 0
3133           && strcmp (b->section->name, ".opd") == 0)
3134         return 1;
3135     }
3136
3137   /* then other code symbols.  */
3138   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3139       == (SEC_CODE | SEC_ALLOC)
3140       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3141          != (SEC_CODE | SEC_ALLOC))
3142     return -1;
3143
3144   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3145       != (SEC_CODE | SEC_ALLOC)
3146       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3147          == (SEC_CODE | SEC_ALLOC))
3148     return 1;
3149
3150   if (synthetic_relocatable)
3151     {
3152       if (a->section->id < b->section->id)
3153         return -1;
3154
3155       if (a->section->id > b->section->id)
3156         return 1;
3157     }
3158
3159   if (a->value + a->section->vma < b->value + b->section->vma)
3160     return -1;
3161
3162   if (a->value + a->section->vma > b->value + b->section->vma)
3163     return 1;
3164
3165   /* For syms with the same value, prefer strong dynamic global function
3166      syms over other syms.  */
3167   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3168     return -1;
3169
3170   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3171     return 1;
3172
3173   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3174     return -1;
3175
3176   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3177     return 1;
3178
3179   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3180     return -1;
3181
3182   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3183     return 1;
3184
3185   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3186     return -1;
3187
3188   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3189     return 1;
3190
3191   return a > b;
3192 }
3193
3194 /* Search SYMS for a symbol of the given VALUE.  */
3195
3196 static asymbol *
3197 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3198 {
3199   long mid;
3200
3201   if (id == (unsigned) -1)
3202     {
3203       while (lo < hi)
3204         {
3205           mid = (lo + hi) >> 1;
3206           if (syms[mid]->value + syms[mid]->section->vma < value)
3207             lo = mid + 1;
3208           else if (syms[mid]->value + syms[mid]->section->vma > value)
3209             hi = mid;
3210           else
3211             return syms[mid];
3212         }
3213     }
3214   else
3215     {
3216       while (lo < hi)
3217         {
3218           mid = (lo + hi) >> 1;
3219           if (syms[mid]->section->id < id)
3220             lo = mid + 1;
3221           else if (syms[mid]->section->id > id)
3222             hi = mid;
3223           else if (syms[mid]->value < value)
3224             lo = mid + 1;
3225           else if (syms[mid]->value > value)
3226             hi = mid;
3227           else
3228             return syms[mid];
3229         }
3230     }
3231   return NULL;
3232 }
3233
3234 static bfd_boolean
3235 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3236 {
3237   bfd_vma vma = *(bfd_vma *) ptr;
3238   return ((section->flags & SEC_ALLOC) != 0
3239           && section->vma <= vma
3240           && vma < section->vma + section->size);
3241 }
3242
3243 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3244    entry syms.  Also generate @plt symbols for the glink branch table.
3245    Returns count of synthetic symbols in RET or -1 on error.  */
3246
3247 static long
3248 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3249                                 long static_count, asymbol **static_syms,
3250                                 long dyn_count, asymbol **dyn_syms,
3251                                 asymbol **ret)
3252 {
3253   asymbol *s;
3254   long i;
3255   long count;
3256   char *names;
3257   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3258   asection *opd = NULL;
3259   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3260   asymbol **syms;
3261   int abi = abiversion (abfd);
3262
3263   *ret = NULL;
3264
3265   if (abi < 2)
3266     {
3267       opd = bfd_get_section_by_name (abfd, ".opd");
3268       if (opd == NULL && abi == 1)
3269         return 0;
3270     }
3271
3272   syms = NULL;
3273   codesecsym = 0;
3274   codesecsymend = 0;
3275   secsymend = 0;
3276   opdsymend = 0;
3277   symcount = 0;
3278   if (opd != NULL)
3279     {
3280       symcount = static_count;
3281       if (!relocatable)
3282         symcount += dyn_count;
3283       if (symcount == 0)
3284         return 0;
3285
3286       syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3287       if (syms == NULL)
3288         return -1;
3289
3290       if (!relocatable && static_count != 0 && dyn_count != 0)
3291         {
3292           /* Use both symbol tables.  */
3293           memcpy (syms, static_syms, static_count * sizeof (*syms));
3294           memcpy (syms + static_count, dyn_syms,
3295                   (dyn_count + 1) * sizeof (*syms));
3296         }
3297       else if (!relocatable && static_count == 0)
3298         memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3299       else
3300         memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3301
3302       synthetic_relocatable = relocatable;
3303       synthetic_opd = opd;
3304       qsort (syms, symcount, sizeof (*syms), compare_symbols);
3305
3306       if (!relocatable && symcount > 1)
3307         {
3308           long j;
3309           /* Trim duplicate syms, since we may have merged the normal and
3310              dynamic symbols.  Actually, we only care about syms that have
3311              different values, so trim any with the same value.  */
3312           for (i = 1, j = 1; i < symcount; ++i)
3313             if (syms[i - 1]->value + syms[i - 1]->section->vma
3314                 != syms[i]->value + syms[i]->section->vma)
3315               syms[j++] = syms[i];
3316           symcount = j;
3317         }
3318
3319       i = 0;
3320       /* Note that here and in compare_symbols we can't compare opd and
3321          sym->section directly.  With separate debug info files, the
3322          symbols will be extracted from the debug file while abfd passed
3323          to this function is the real binary.  */
3324       if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3325         ++i;
3326       codesecsym = i;
3327
3328       for (; i < symcount; ++i)
3329         if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3330                                          | SEC_THREAD_LOCAL))
3331              != (SEC_CODE | SEC_ALLOC))
3332             || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3333           break;
3334       codesecsymend = i;
3335
3336       for (; i < symcount; ++i)
3337         if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3338           break;
3339       secsymend = i;
3340
3341       for (; i < symcount; ++i)
3342         if (strcmp (syms[i]->section->name, ".opd") != 0)
3343           break;
3344       opdsymend = i;
3345
3346       for (; i < symcount; ++i)
3347         if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3348             != (SEC_CODE | SEC_ALLOC))
3349           break;
3350       symcount = i;
3351     }
3352   count = 0;
3353
3354   if (relocatable)
3355     {
3356       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3357       arelent *r;
3358       size_t size;
3359       long relcount;
3360
3361       if (opdsymend == secsymend)
3362         goto done;
3363
3364       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3365       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3366       if (relcount == 0)
3367         goto done;
3368
3369       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3370         {
3371           count = -1;
3372           goto done;
3373         }
3374
3375       size = 0;
3376       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3377         {
3378           asymbol *sym;
3379
3380           while (r < opd->relocation + relcount
3381                  && r->address < syms[i]->value + opd->vma)
3382             ++r;
3383
3384           if (r == opd->relocation + relcount)
3385             break;
3386
3387           if (r->address != syms[i]->value + opd->vma)
3388             continue;
3389
3390           if (r->howto->type != R_PPC64_ADDR64)
3391             continue;
3392
3393           sym = *r->sym_ptr_ptr;
3394           if (!sym_exists_at (syms, opdsymend, symcount,
3395                               sym->section->id, sym->value + r->addend))
3396             {
3397               ++count;
3398               size += sizeof (asymbol);
3399               size += strlen (syms[i]->name) + 2;
3400             }
3401         }
3402
3403       if (size == 0)
3404         goto done;
3405       s = *ret = bfd_malloc (size);
3406       if (s == NULL)
3407         {
3408           count = -1;
3409           goto done;
3410         }
3411
3412       names = (char *) (s + count);
3413
3414       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3415         {
3416           asymbol *sym;
3417
3418           while (r < opd->relocation + relcount
3419                  && r->address < syms[i]->value + opd->vma)
3420             ++r;
3421
3422           if (r == opd->relocation + relcount)
3423             break;
3424
3425           if (r->address != syms[i]->value + opd->vma)
3426             continue;
3427
3428           if (r->howto->type != R_PPC64_ADDR64)
3429             continue;
3430
3431           sym = *r->sym_ptr_ptr;
3432           if (!sym_exists_at (syms, opdsymend, symcount,
3433                               sym->section->id, sym->value + r->addend))
3434             {
3435               size_t len;
3436
3437               *s = *syms[i];
3438               s->flags |= BSF_SYNTHETIC;
3439               s->section = sym->section;
3440               s->value = sym->value + r->addend;
3441               s->name = names;
3442               *names++ = '.';
3443               len = strlen (syms[i]->name);
3444               memcpy (names, syms[i]->name, len + 1);
3445               names += len + 1;
3446               /* Have udata.p point back to the original symbol this
3447                  synthetic symbol was derived from.  */
3448               s->udata.p = syms[i];
3449               s++;
3450             }
3451         }
3452     }
3453   else
3454     {
3455       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3456       bfd_byte *contents = NULL;
3457       size_t size;
3458       long plt_count = 0;
3459       bfd_vma glink_vma = 0, resolv_vma = 0;
3460       asection *dynamic, *glink = NULL, *relplt = NULL;
3461       arelent *p;
3462
3463       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3464         {
3465         free_contents_and_exit_err:
3466           count = -1;
3467         free_contents_and_exit:
3468           if (contents)
3469             free (contents);
3470           goto done;
3471         }
3472
3473       size = 0;
3474       for (i = secsymend; i < opdsymend; ++i)
3475         {
3476           bfd_vma ent;
3477
3478           /* Ignore bogus symbols.  */
3479           if (syms[i]->value > opd->size - 8)
3480             continue;
3481
3482           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3483           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3484             {
3485               ++count;
3486               size += sizeof (asymbol);
3487               size += strlen (syms[i]->name) + 2;
3488             }
3489         }
3490
3491       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3492       if (dyn_count != 0
3493           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3494         {
3495           bfd_byte *dynbuf, *extdyn, *extdynend;
3496           size_t extdynsize;
3497           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3498
3499           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3500             goto free_contents_and_exit_err;
3501
3502           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3503           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3504
3505           extdyn = dynbuf;
3506           extdynend = extdyn + dynamic->size;
3507           for (; extdyn < extdynend; extdyn += extdynsize)
3508             {
3509               Elf_Internal_Dyn dyn;
3510               (*swap_dyn_in) (abfd, extdyn, &dyn);
3511
3512               if (dyn.d_tag == DT_NULL)
3513                 break;
3514
3515               if (dyn.d_tag == DT_PPC64_GLINK)
3516                 {
3517                   /* The first glink stub starts at offset 32; see
3518                      comment in ppc64_elf_finish_dynamic_sections. */
3519                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3520                   /* The .glink section usually does not survive the final
3521                      link; search for the section (usually .text) where the
3522                      glink stubs now reside.  */
3523                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3524                                                 &glink_vma);
3525                   break;
3526                 }
3527             }
3528
3529           free (dynbuf);
3530         }
3531
3532       if (glink != NULL)
3533         {
3534           /* Determine __glink trampoline by reading the relative branch
3535              from the first glink stub.  */
3536           bfd_byte buf[4];
3537           unsigned int off = 0;
3538
3539           while (bfd_get_section_contents (abfd, glink, buf,
3540                                            glink_vma + off - glink->vma, 4))
3541             {
3542               unsigned int insn = bfd_get_32 (abfd, buf);
3543               insn ^= B_DOT;
3544               if ((insn & ~0x3fffffc) == 0)
3545                 {
3546                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3547                   break;
3548                 }
3549               off += 4;
3550               if (off > 4)
3551                 break;
3552             }
3553
3554           if (resolv_vma)
3555             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3556
3557           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3558           if (relplt != NULL)
3559             {
3560               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3561               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3562                 goto free_contents_and_exit_err;
3563
3564               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3565               size += plt_count * sizeof (asymbol);
3566
3567               p = relplt->relocation;
3568               for (i = 0; i < plt_count; i++, p++)
3569                 {
3570                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3571                   if (p->addend != 0)
3572                     size += sizeof ("+0x") - 1 + 16;
3573                 }
3574             }
3575         }
3576
3577       if (size == 0)
3578         goto free_contents_and_exit;
3579       s = *ret = bfd_malloc (size);
3580       if (s == NULL)
3581         goto free_contents_and_exit_err;
3582
3583       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3584
3585       for (i = secsymend; i < opdsymend; ++i)
3586         {
3587           bfd_vma ent;
3588
3589           if (syms[i]->value > opd->size - 8)
3590             continue;
3591
3592           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3593           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3594             {
3595               long lo, hi;
3596               size_t len;
3597               asection *sec = abfd->sections;
3598
3599               *s = *syms[i];
3600               lo = codesecsym;
3601               hi = codesecsymend;
3602               while (lo < hi)
3603                 {
3604                   long mid = (lo + hi) >> 1;
3605                   if (syms[mid]->section->vma < ent)
3606                     lo = mid + 1;
3607                   else if (syms[mid]->section->vma > ent)
3608                     hi = mid;
3609                   else
3610                     {
3611                       sec = syms[mid]->section;
3612                       break;
3613                     }
3614                 }
3615
3616               if (lo >= hi && lo > codesecsym)
3617                 sec = syms[lo - 1]->section;
3618
3619               for (; sec != NULL; sec = sec->next)
3620                 {
3621                   if (sec->vma > ent)
3622                     break;
3623                   /* SEC_LOAD may not be set if SEC is from a separate debug
3624                      info file.  */
3625                   if ((sec->flags & SEC_ALLOC) == 0)
3626                     break;
3627                   if ((sec->flags & SEC_CODE) != 0)
3628                     s->section = sec;
3629                 }
3630               s->flags |= BSF_SYNTHETIC;
3631               s->value = ent - s->section->vma;
3632               s->name = names;
3633               *names++ = '.';
3634               len = strlen (syms[i]->name);
3635               memcpy (names, syms[i]->name, len + 1);
3636               names += len + 1;
3637               /* Have udata.p point back to the original symbol this
3638                  synthetic symbol was derived from.  */
3639               s->udata.p = syms[i];
3640               s++;
3641             }
3642         }
3643       free (contents);
3644
3645       if (glink != NULL && relplt != NULL)
3646         {
3647           if (resolv_vma)
3648             {
3649               /* Add a symbol for the main glink trampoline.  */
3650               memset (s, 0, sizeof *s);
3651               s->the_bfd = abfd;
3652               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3653               s->section = glink;
3654               s->value = resolv_vma - glink->vma;
3655               s->name = names;
3656               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3657               names += sizeof ("__glink_PLTresolve");
3658               s++;
3659               count++;
3660             }
3661
3662           /* FIXME: It would be very much nicer to put sym@plt on the
3663              stub rather than on the glink branch table entry.  The
3664              objdump disassembler would then use a sensible symbol
3665              name on plt calls.  The difficulty in doing so is
3666              a) finding the stubs, and,
3667              b) matching stubs against plt entries, and,
3668              c) there can be multiple stubs for a given plt entry.
3669
3670              Solving (a) could be done by code scanning, but older
3671              ppc64 binaries used different stubs to current code.
3672              (b) is the tricky one since you need to known the toc
3673              pointer for at least one function that uses a pic stub to
3674              be able to calculate the plt address referenced.
3675              (c) means gdb would need to set multiple breakpoints (or
3676              find the glink branch itself) when setting breakpoints
3677              for pending shared library loads.  */
3678           p = relplt->relocation;
3679           for (i = 0; i < plt_count; i++, p++)
3680             {
3681               size_t len;
3682
3683               *s = **p->sym_ptr_ptr;
3684               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3685                  we are defining a symbol, ensure one of them is set.  */
3686               if ((s->flags & BSF_LOCAL) == 0)
3687                 s->flags |= BSF_GLOBAL;
3688               s->flags |= BSF_SYNTHETIC;
3689               s->section = glink;
3690               s->value = glink_vma - glink->vma;
3691               s->name = names;
3692               s->udata.p = NULL;
3693               len = strlen ((*p->sym_ptr_ptr)->name);
3694               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3695               names += len;
3696               if (p->addend != 0)
3697                 {
3698                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3699                   names += sizeof ("+0x") - 1;
3700                   bfd_sprintf_vma (abfd, names, p->addend);
3701                   names += strlen (names);
3702                 }
3703               memcpy (names, "@plt", sizeof ("@plt"));
3704               names += sizeof ("@plt");
3705               s++;
3706               if (abi < 2)
3707                 {
3708                   glink_vma += 8;
3709                   if (i >= 0x8000)
3710                     glink_vma += 4;
3711                 }
3712               else
3713                 glink_vma += 4;
3714             }
3715           count += plt_count;
3716         }
3717     }
3718
3719  done:
3720   free (syms);
3721   return count;
3722 }
3723 \f
3724 /* The following functions are specific to the ELF linker, while
3725    functions above are used generally.  Those named ppc64_elf_* are
3726    called by the main ELF linker code.  They appear in this file more
3727    or less in the order in which they are called.  eg.
3728    ppc64_elf_check_relocs is called early in the link process,
3729    ppc64_elf_finish_dynamic_sections is one of the last functions
3730    called.
3731
3732    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3733    functions have both a function code symbol and a function descriptor
3734    symbol.  A call to foo in a relocatable object file looks like:
3735
3736    .            .text
3737    .    x:
3738    .            bl      .foo
3739    .            nop
3740
3741    The function definition in another object file might be:
3742
3743    .            .section .opd
3744    .    foo:    .quad   .foo
3745    .            .quad   .TOC.@tocbase
3746    .            .quad   0
3747    .
3748    .            .text
3749    .    .foo:   blr
3750
3751    When the linker resolves the call during a static link, the branch
3752    unsurprisingly just goes to .foo and the .opd information is unused.
3753    If the function definition is in a shared library, things are a little
3754    different:  The call goes via a plt call stub, the opd information gets
3755    copied to the plt, and the linker patches the nop.
3756
3757    .    x:
3758    .            bl      .foo_stub
3759    .            ld      2,40(1)
3760    .
3761    .
3762    .    .foo_stub:
3763    .            std     2,40(1)                 # in practice, the call stub
3764    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3765    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3766    .            ld      12,0(11)
3767    .            ld      2,8(11)
3768    .            mtctr   12
3769    .            ld      11,16(11)
3770    .            bctr
3771    .
3772    .            .section .plt
3773    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3774
3775    The "reloc ()" notation is supposed to indicate that the linker emits
3776    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3777    copying.
3778
3779    What are the difficulties here?  Well, firstly, the relocations
3780    examined by the linker in check_relocs are against the function code
3781    sym .foo, while the dynamic relocation in the plt is emitted against
3782    the function descriptor symbol, foo.  Somewhere along the line, we need
3783    to carefully copy dynamic link information from one symbol to the other.
3784    Secondly, the generic part of the elf linker will make .foo a dynamic
3785    symbol as is normal for most other backends.  We need foo dynamic
3786    instead, at least for an application final link.  However, when
3787    creating a shared library containing foo, we need to have both symbols
3788    dynamic so that references to .foo are satisfied during the early
3789    stages of linking.  Otherwise the linker might decide to pull in a
3790    definition from some other object, eg. a static library.
3791
3792    Update: As of August 2004, we support a new convention.  Function
3793    calls may use the function descriptor symbol, ie. "bl foo".  This
3794    behaves exactly as "bl .foo".  */
3795
3796 /* Of those relocs that might be copied as dynamic relocs, this
3797    function selects those that must be copied when linking a shared
3798    library or PIE, even when the symbol is local.  */
3799
3800 static int
3801 must_be_dyn_reloc (struct bfd_link_info *info,
3802                    enum elf_ppc64_reloc_type r_type)
3803 {
3804   switch (r_type)
3805     {
3806     default:
3807       /* Only relative relocs can be resolved when the object load
3808          address isn't fixed.  DTPREL64 is excluded because the
3809          dynamic linker needs to differentiate global dynamic from
3810          local dynamic __tls_index pairs when PPC64_OPT_TLS is set.  */
3811       return 1;
3812
3813     case R_PPC64_REL32:
3814     case R_PPC64_REL64:
3815     case R_PPC64_REL30:
3816       return 0;
3817
3818     case R_PPC64_TPREL16:
3819     case R_PPC64_TPREL16_LO:
3820     case R_PPC64_TPREL16_HI:
3821     case R_PPC64_TPREL16_HA:
3822     case R_PPC64_TPREL16_DS:
3823     case R_PPC64_TPREL16_LO_DS:
3824     case R_PPC64_TPREL16_HIGH:
3825     case R_PPC64_TPREL16_HIGHA:
3826     case R_PPC64_TPREL16_HIGHER:
3827     case R_PPC64_TPREL16_HIGHERA:
3828     case R_PPC64_TPREL16_HIGHEST:
3829     case R_PPC64_TPREL16_HIGHESTA:
3830     case R_PPC64_TPREL64:
3831       /* These relocations are relative but in a shared library the
3832          linker doesn't know the thread pointer base.  */
3833       return bfd_link_dll (info);
3834     }
3835 }
3836
3837 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3838    copying dynamic variables from a shared lib into an app's dynbss
3839    section, and instead use a dynamic relocation to point into the
3840    shared lib.  With code that gcc generates, it's vital that this be
3841    enabled;  In the PowerPC64 ABI, the address of a function is actually
3842    the address of a function descriptor, which resides in the .opd
3843    section.  gcc uses the descriptor directly rather than going via the
3844    GOT as some other ABI's do, which means that initialized function
3845    pointers must reference the descriptor.  Thus, a function pointer
3846    initialized to the address of a function in a shared library will
3847    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3848    redefines the function descriptor symbol to point to the copy.  This
3849    presents a problem as a plt entry for that function is also
3850    initialized from the function descriptor symbol and the copy reloc
3851    may not be initialized first.  */
3852 #define ELIMINATE_COPY_RELOCS 1
3853
3854 /* Section name for stubs is the associated section name plus this
3855    string.  */
3856 #define STUB_SUFFIX ".stub"
3857
3858 /* Linker stubs.
3859    ppc_stub_long_branch:
3860    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3861    destination, but a 24 bit branch in a stub section will reach.
3862    .    b       dest
3863
3864    ppc_stub_plt_branch:
3865    Similar to the above, but a 24 bit branch in the stub section won't
3866    reach its destination.
3867    .    addis   %r11,%r2,xxx@toc@ha
3868    .    ld      %r12,xxx@toc@l(%r11)
3869    .    mtctr   %r12
3870    .    bctr
3871
3872    ppc_stub_plt_call:
3873    Used to call a function in a shared library.  If it so happens that
3874    the plt entry referenced crosses a 64k boundary, then an extra
3875    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3876    .    std     %r2,40(%r1)
3877    .    addis   %r11,%r2,xxx@toc@ha
3878    .    ld      %r12,xxx+0@toc@l(%r11)
3879    .    mtctr   %r12
3880    .    ld      %r2,xxx+8@toc@l(%r11)
3881    .    ld      %r11,xxx+16@toc@l(%r11)
3882    .    bctr
3883
3884    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3885    code to adjust the value and save r2 to support multiple toc sections.
3886    A ppc_stub_long_branch with an r2 offset looks like:
3887    .    std     %r2,40(%r1)
3888    .    addis   %r2,%r2,off@ha
3889    .    addi    %r2,%r2,off@l
3890    .    b       dest
3891
3892    A ppc_stub_plt_branch with an r2 offset looks like:
3893    .    std     %r2,40(%r1)
3894    .    addis   %r11,%r2,xxx@toc@ha
3895    .    ld      %r12,xxx@toc@l(%r11)
3896    .    addis   %r2,%r2,off@ha
3897    .    addi    %r2,%r2,off@l
3898    .    mtctr   %r12
3899    .    bctr
3900
3901    In cases where the "addis" instruction would add zero, the "addis" is
3902    omitted and following instructions modified slightly in some cases.
3903 */
3904
3905 enum ppc_stub_type {
3906   ppc_stub_none,
3907   ppc_stub_long_branch,
3908   ppc_stub_long_branch_r2off,
3909   ppc_stub_plt_branch,
3910   ppc_stub_plt_branch_r2off,
3911   ppc_stub_plt_call,
3912   ppc_stub_plt_call_r2save,
3913   ppc_stub_global_entry,
3914   ppc_stub_save_res
3915 };
3916
3917 /* Information on stub grouping.  */
3918 struct map_stub
3919 {
3920   /* The stub section.  */
3921   asection *stub_sec;
3922   /* This is the section to which stubs in the group will be attached.  */
3923   asection *link_sec;
3924   /* Next group.  */
3925   struct map_stub *next;
3926   /* Whether to emit a copy of register save/restore functions in this
3927      group.  */
3928   int needs_save_res;
3929   /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3930      or -1u if no such stub with bctrl exists.  */
3931   unsigned int tls_get_addr_opt_bctrl;
3932 };
3933
3934 struct ppc_stub_hash_entry {
3935
3936   /* Base hash table entry structure.  */
3937   struct bfd_hash_entry root;
3938
3939   enum ppc_stub_type stub_type;
3940
3941   /* Group information.  */
3942   struct map_stub *group;
3943
3944   /* Offset within stub_sec of the beginning of this stub.  */
3945   bfd_vma stub_offset;
3946
3947   /* Given the symbol's value and its section we can determine its final
3948      value when building the stubs (so the stub knows where to jump.  */
3949   bfd_vma target_value;
3950   asection *target_section;
3951
3952   /* The symbol table entry, if any, that this was derived from.  */
3953   struct ppc_link_hash_entry *h;
3954   struct plt_entry *plt_ent;
3955
3956   /* Symbol st_other.  */
3957   unsigned char other;
3958 };
3959
3960 struct ppc_branch_hash_entry {
3961
3962   /* Base hash table entry structure.  */
3963   struct bfd_hash_entry root;
3964
3965   /* Offset within branch lookup table.  */
3966   unsigned int offset;
3967
3968   /* Generation marker.  */
3969   unsigned int iter;
3970 };
3971
3972 /* Used to track dynamic relocations for local symbols.  */
3973 struct ppc_dyn_relocs
3974 {
3975   struct ppc_dyn_relocs *next;
3976
3977   /* The input section of the reloc.  */
3978   asection *sec;
3979
3980   /* Total number of relocs copied for the input section.  */
3981   unsigned int count : 31;
3982
3983   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3984   unsigned int ifunc : 1;
3985 };
3986
3987 struct ppc_link_hash_entry
3988 {
3989   struct elf_link_hash_entry elf;
3990
3991   union {
3992     /* A pointer to the most recently used stub hash entry against this
3993        symbol.  */
3994     struct ppc_stub_hash_entry *stub_cache;
3995
3996     /* A pointer to the next symbol starting with a '.'  */
3997     struct ppc_link_hash_entry *next_dot_sym;
3998   } u;
3999
4000   /* Track dynamic relocs copied for this symbol.  */
4001   struct elf_dyn_relocs *dyn_relocs;
4002
4003   /* Chain of aliases referring to a weakdef.  */
4004   struct ppc_link_hash_entry *weakref;
4005
4006   /* Link between function code and descriptor symbols.  */
4007   struct ppc_link_hash_entry *oh;
4008
4009   /* Flag function code and descriptor symbols.  */
4010   unsigned int is_func:1;
4011   unsigned int is_func_descriptor:1;
4012   unsigned int fake:1;
4013
4014   /* Whether global opd/toc sym has been adjusted or not.
4015      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4016      should be set for all globals defined in any opd/toc section.  */
4017   unsigned int adjust_done:1;
4018
4019   /* Set if this is an out-of-line register save/restore function,
4020      with non-standard calling convention.  */
4021   unsigned int save_res:1;
4022
4023   /* Set if a duplicate symbol with non-zero localentry is detected,
4024      even when the duplicate symbol does not provide a definition.  */
4025   unsigned int non_zero_localentry:1;
4026
4027   /* Contexts in which symbol is used in the GOT (or TOC).
4028      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4029      corresponding relocs are encountered during check_relocs.
4030      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4031      indicate the corresponding GOT entry type is not needed.
4032      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4033      a TPREL one.  We use a separate flag rather than setting TPREL
4034      just for convenience in distinguishing the two cases.  */
4035 #define TLS_GD           1      /* GD reloc. */
4036 #define TLS_LD           2      /* LD reloc. */
4037 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
4038 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4039 #define TLS_TLS         16      /* Any TLS reloc.  */
4040 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4041 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4042 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4043   unsigned char tls_mask;
4044 };
4045
4046 /* ppc64 ELF linker hash table.  */
4047
4048 struct ppc_link_hash_table
4049 {
4050   struct elf_link_hash_table elf;
4051
4052   /* The stub hash table.  */
4053   struct bfd_hash_table stub_hash_table;
4054
4055   /* Another hash table for plt_branch stubs.  */
4056   struct bfd_hash_table branch_hash_table;
4057
4058   /* Hash table for function prologue tocsave.  */
4059   htab_t tocsave_htab;
4060
4061   /* Various options and other info passed from the linker.  */
4062   struct ppc64_elf_params *params;
4063
4064   /* The size of sec_info below.  */
4065   unsigned int sec_info_arr_size;
4066
4067   /* Per-section array of extra section info.  Done this way rather
4068      than as part of ppc64_elf_section_data so we have the info for
4069      non-ppc64 sections.  */
4070   struct
4071   {
4072     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4073     bfd_vma toc_off;
4074
4075     union
4076     {
4077       /* The section group that this section belongs to.  */
4078       struct map_stub *group;
4079       /* A temp section list pointer.  */
4080       asection *list;
4081     } u;
4082   } *sec_info;
4083
4084   /* Linked list of groups.  */
4085   struct map_stub *group;
4086
4087   /* Temp used when calculating TOC pointers.  */
4088   bfd_vma toc_curr;
4089   bfd *toc_bfd;
4090   asection *toc_first_sec;
4091
4092   /* Used when adding symbols.  */
4093   struct ppc_link_hash_entry *dot_syms;
4094
4095   /* Shortcuts to get to dynamic linker sections.  */
4096   asection *glink;
4097   asection *sfpr;
4098   asection *brlt;
4099   asection *relbrlt;
4100   asection *glink_eh_frame;
4101
4102   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4103   struct ppc_link_hash_entry *tls_get_addr;
4104   struct ppc_link_hash_entry *tls_get_addr_fd;
4105
4106   /* The size of reliplt used by got entry relocs.  */
4107   bfd_size_type got_reli_size;
4108
4109   /* Statistics.  */
4110   unsigned long stub_count[ppc_stub_global_entry];
4111
4112   /* Number of stubs against global syms.  */
4113   unsigned long stub_globals;
4114
4115   /* Set if we're linking code with function descriptors.  */
4116   unsigned int opd_abi:1;
4117
4118   /* Support for multiple toc sections.  */
4119   unsigned int do_multi_toc:1;
4120   unsigned int multi_toc_needed:1;
4121   unsigned int second_toc_pass:1;
4122   unsigned int do_toc_opt:1;
4123
4124   /* Set if tls optimization is enabled.  */
4125   unsigned int do_tls_opt:1;
4126
4127   /* Set on error.  */
4128   unsigned int stub_error:1;
4129
4130   /* Whether func_desc_adjust needs to be run over symbols.  */
4131   unsigned int need_func_desc_adj:1;
4132
4133   /* Whether there exist local gnu indirect function resolvers,
4134      referenced by dynamic relocations.  */
4135   unsigned int local_ifunc_resolver:1;
4136   unsigned int maybe_local_ifunc_resolver:1;
4137
4138   /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized.  */
4139   unsigned int has_plt_localentry0:1;
4140
4141   /* Incremented every time we size stubs.  */
4142   unsigned int stub_iteration;
4143
4144   /* Small local sym cache.  */
4145   struct sym_cache sym_cache;
4146 };
4147
4148 /* Rename some of the generic section flags to better document how they
4149    are used here.  */
4150
4151 /* Nonzero if this section has TLS related relocations.  */
4152 #define has_tls_reloc sec_flg0
4153
4154 /* Nonzero if this section has a call to __tls_get_addr.  */
4155 #define has_tls_get_addr_call sec_flg1
4156
4157 /* Nonzero if this section has any toc or got relocs.  */
4158 #define has_toc_reloc sec_flg2
4159
4160 /* Nonzero if this section has a call to another section that uses
4161    the toc or got.  */
4162 #define makes_toc_func_call sec_flg3
4163
4164 /* Recursion protection when determining above flag.  */
4165 #define call_check_in_progress sec_flg4
4166 #define call_check_done sec_flg5
4167
4168 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4169
4170 #define ppc_hash_table(p) \
4171   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4172   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4173
4174 #define ppc_stub_hash_lookup(table, string, create, copy) \
4175   ((struct ppc_stub_hash_entry *) \
4176    bfd_hash_lookup ((table), (string), (create), (copy)))
4177
4178 #define ppc_branch_hash_lookup(table, string, create, copy) \
4179   ((struct ppc_branch_hash_entry *) \
4180    bfd_hash_lookup ((table), (string), (create), (copy)))
4181
4182 /* Create an entry in the stub hash table.  */
4183
4184 static struct bfd_hash_entry *
4185 stub_hash_newfunc (struct bfd_hash_entry *entry,
4186                    struct bfd_hash_table *table,
4187                    const char *string)
4188 {
4189   /* Allocate the structure if it has not already been allocated by a
4190      subclass.  */
4191   if (entry == NULL)
4192     {
4193       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4194       if (entry == NULL)
4195         return entry;
4196     }
4197
4198   /* Call the allocation method of the superclass.  */
4199   entry = bfd_hash_newfunc (entry, table, string);
4200   if (entry != NULL)
4201     {
4202       struct ppc_stub_hash_entry *eh;
4203
4204       /* Initialize the local fields.  */
4205       eh = (struct ppc_stub_hash_entry *) entry;
4206       eh->stub_type = ppc_stub_none;
4207       eh->group = NULL;
4208       eh->stub_offset = 0;
4209       eh->target_value = 0;
4210       eh->target_section = NULL;
4211       eh->h = NULL;
4212       eh->plt_ent = NULL;
4213       eh->other = 0;
4214     }
4215
4216   return entry;
4217 }
4218
4219 /* Create an entry in the branch hash table.  */
4220
4221 static struct bfd_hash_entry *
4222 branch_hash_newfunc (struct bfd_hash_entry *entry,
4223                      struct bfd_hash_table *table,
4224                      const char *string)
4225 {
4226   /* Allocate the structure if it has not already been allocated by a
4227      subclass.  */
4228   if (entry == NULL)
4229     {
4230       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4231       if (entry == NULL)
4232         return entry;
4233     }
4234
4235   /* Call the allocation method of the superclass.  */
4236   entry = bfd_hash_newfunc (entry, table, string);
4237   if (entry != NULL)
4238     {
4239       struct ppc_branch_hash_entry *eh;
4240
4241       /* Initialize the local fields.  */
4242       eh = (struct ppc_branch_hash_entry *) entry;
4243       eh->offset = 0;
4244       eh->iter = 0;
4245     }
4246
4247   return entry;
4248 }
4249
4250 /* Create an entry in a ppc64 ELF linker hash table.  */
4251
4252 static struct bfd_hash_entry *
4253 link_hash_newfunc (struct bfd_hash_entry *entry,
4254                    struct bfd_hash_table *table,
4255                    const char *string)
4256 {
4257   /* Allocate the structure if it has not already been allocated by a
4258      subclass.  */
4259   if (entry == NULL)
4260     {
4261       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4262       if (entry == NULL)
4263         return entry;
4264     }
4265
4266   /* Call the allocation method of the superclass.  */
4267   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4268   if (entry != NULL)
4269     {
4270       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4271
4272       memset (&eh->u.stub_cache, 0,
4273               (sizeof (struct ppc_link_hash_entry)
4274                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4275
4276       /* When making function calls, old ABI code references function entry
4277          points (dot symbols), while new ABI code references the function
4278          descriptor symbol.  We need to make any combination of reference and
4279          definition work together, without breaking archive linking.
4280
4281          For a defined function "foo" and an undefined call to "bar":
4282          An old object defines "foo" and ".foo", references ".bar" (possibly
4283          "bar" too).
4284          A new object defines "foo" and references "bar".
4285
4286          A new object thus has no problem with its undefined symbols being
4287          satisfied by definitions in an old object.  On the other hand, the
4288          old object won't have ".bar" satisfied by a new object.
4289
4290          Keep a list of newly added dot-symbols.  */
4291
4292       if (string[0] == '.')
4293         {
4294           struct ppc_link_hash_table *htab;
4295
4296           htab = (struct ppc_link_hash_table *) table;
4297           eh->u.next_dot_sym = htab->dot_syms;
4298           htab->dot_syms = eh;
4299         }
4300     }
4301
4302   return entry;
4303 }
4304
4305 struct tocsave_entry {
4306   asection *sec;
4307   bfd_vma offset;
4308 };
4309
4310 static hashval_t
4311 tocsave_htab_hash (const void *p)
4312 {
4313   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4314   return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4315 }
4316
4317 static int
4318 tocsave_htab_eq (const void *p1, const void *p2)
4319 {
4320   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4321   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4322   return e1->sec == e2->sec && e1->offset == e2->offset;
4323 }
4324
4325 /* Destroy a ppc64 ELF linker hash table.  */
4326
4327 static void
4328 ppc64_elf_link_hash_table_free (bfd *obfd)
4329 {
4330   struct ppc_link_hash_table *htab;
4331
4332   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4333   if (htab->tocsave_htab)
4334     htab_delete (htab->tocsave_htab);
4335   bfd_hash_table_free (&htab->branch_hash_table);
4336   bfd_hash_table_free (&htab->stub_hash_table);
4337   _bfd_elf_link_hash_table_free (obfd);
4338 }
4339
4340 /* Create a ppc64 ELF linker hash table.  */
4341
4342 static struct bfd_link_hash_table *
4343 ppc64_elf_link_hash_table_create (bfd *abfd)
4344 {
4345   struct ppc_link_hash_table *htab;
4346   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4347
4348   htab = bfd_zmalloc (amt);
4349   if (htab == NULL)
4350     return NULL;
4351
4352   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4353                                       sizeof (struct ppc_link_hash_entry),
4354                                       PPC64_ELF_DATA))
4355     {
4356       free (htab);
4357       return NULL;
4358     }
4359
4360   /* Init the stub hash table too.  */
4361   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4362                             sizeof (struct ppc_stub_hash_entry)))
4363     {
4364       _bfd_elf_link_hash_table_free (abfd);
4365       return NULL;
4366     }
4367
4368   /* And the branch hash table.  */
4369   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4370                             sizeof (struct ppc_branch_hash_entry)))
4371     {
4372       bfd_hash_table_free (&htab->stub_hash_table);
4373       _bfd_elf_link_hash_table_free (abfd);
4374       return NULL;
4375     }
4376
4377   htab->tocsave_htab = htab_try_create (1024,
4378                                         tocsave_htab_hash,
4379                                         tocsave_htab_eq,
4380                                         NULL);
4381   if (htab->tocsave_htab == NULL)
4382     {
4383       ppc64_elf_link_hash_table_free (abfd);
4384       return NULL;
4385     }
4386   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4387
4388   /* Initializing two fields of the union is just cosmetic.  We really
4389      only care about glist, but when compiled on a 32-bit host the
4390      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4391      debugger inspection of these fields look nicer.  */
4392   htab->elf.init_got_refcount.refcount = 0;
4393   htab->elf.init_got_refcount.glist = NULL;
4394   htab->elf.init_plt_refcount.refcount = 0;
4395   htab->elf.init_plt_refcount.glist = NULL;
4396   htab->elf.init_got_offset.offset = 0;
4397   htab->elf.init_got_offset.glist = NULL;
4398   htab->elf.init_plt_offset.offset = 0;
4399   htab->elf.init_plt_offset.glist = NULL;
4400
4401   return &htab->elf.root;
4402 }
4403
4404 /* Create sections for linker generated code.  */
4405
4406 static bfd_boolean
4407 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4408 {
4409   struct ppc_link_hash_table *htab;
4410   flagword flags;
4411
4412   htab = ppc_hash_table (info);
4413
4414   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4415            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4416   if (htab->params->save_restore_funcs)
4417     {
4418       /* Create .sfpr for code to save and restore fp regs.  */
4419       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4420                                                        flags);
4421       if (htab->sfpr == NULL
4422           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4423         return FALSE;
4424     }
4425
4426   if (bfd_link_relocatable (info))
4427     return TRUE;
4428
4429   /* Create .glink for lazy dynamic linking support.  */
4430   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4431                                                     flags);
4432   if (htab->glink == NULL
4433       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4434     return FALSE;
4435
4436   if (!info->no_ld_generated_unwind_info)
4437     {
4438       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4439                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4440       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4441                                                                  ".eh_frame",
4442                                                                  flags);
4443       if (htab->glink_eh_frame == NULL
4444           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4445         return FALSE;
4446     }
4447
4448   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4449   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4450   if (htab->elf.iplt == NULL
4451       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4452     return FALSE;
4453
4454   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4455            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4456   htab->elf.irelplt
4457     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4458   if (htab->elf.irelplt == NULL
4459       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4460     return FALSE;
4461
4462   /* Create branch lookup table for plt_branch stubs.  */
4463   flags = (SEC_ALLOC | SEC_LOAD
4464            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4465   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4466                                                    flags);
4467   if (htab->brlt == NULL
4468       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4469     return FALSE;
4470
4471   if (!bfd_link_pic (info))
4472     return TRUE;
4473
4474   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4475            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4476   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4477                                                       ".rela.branch_lt",
4478                                                       flags);
4479   if (htab->relbrlt == NULL
4480       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4481     return FALSE;
4482
4483   return TRUE;
4484 }
4485
4486 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4487
4488 bfd_boolean
4489 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4490                          struct ppc64_elf_params *params)
4491 {
4492   struct ppc_link_hash_table *htab;
4493
4494   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4495
4496 /* Always hook our dynamic sections into the first bfd, which is the
4497    linker created stub bfd.  This ensures that the GOT header is at
4498    the start of the output TOC section.  */
4499   htab = ppc_hash_table (info);
4500   htab->elf.dynobj = params->stub_bfd;
4501   htab->params = params;
4502
4503   return create_linkage_sections (htab->elf.dynobj, info);
4504 }
4505
4506 /* Build a name for an entry in the stub hash table.  */
4507
4508 static char *
4509 ppc_stub_name (const asection *input_section,
4510                const asection *sym_sec,
4511                const struct ppc_link_hash_entry *h,
4512                const Elf_Internal_Rela *rel)
4513 {
4514   char *stub_name;
4515   ssize_t len;
4516
4517   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4518      offsets from a sym as a branch target?  In fact, we could
4519      probably assume the addend is always zero.  */
4520   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4521
4522   if (h)
4523     {
4524       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4525       stub_name = bfd_malloc (len);
4526       if (stub_name == NULL)
4527         return stub_name;
4528
4529       len = sprintf (stub_name, "%08x.%s+%x",
4530                      input_section->id & 0xffffffff,
4531                      h->elf.root.root.string,
4532                      (int) rel->r_addend & 0xffffffff);
4533     }
4534   else
4535     {
4536       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4537       stub_name = bfd_malloc (len);
4538       if (stub_name == NULL)
4539         return stub_name;
4540
4541       len = sprintf (stub_name, "%08x.%x:%x+%x",
4542                      input_section->id & 0xffffffff,
4543                      sym_sec->id & 0xffffffff,
4544                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4545                      (int) rel->r_addend & 0xffffffff);
4546     }
4547   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4548     stub_name[len - 2] = 0;
4549   return stub_name;
4550 }
4551
4552 /* Look up an entry in the stub hash.  Stub entries are cached because
4553    creating the stub name takes a bit of time.  */
4554
4555 static struct ppc_stub_hash_entry *
4556 ppc_get_stub_entry (const asection *input_section,
4557                     const asection *sym_sec,
4558                     struct ppc_link_hash_entry *h,
4559                     const Elf_Internal_Rela *rel,
4560                     struct ppc_link_hash_table *htab)
4561 {
4562   struct ppc_stub_hash_entry *stub_entry;
4563   struct map_stub *group;
4564
4565   /* If this input section is part of a group of sections sharing one
4566      stub section, then use the id of the first section in the group.
4567      Stub names need to include a section id, as there may well be
4568      more than one stub used to reach say, printf, and we need to
4569      distinguish between them.  */
4570   group = htab->sec_info[input_section->id].u.group;
4571   if (group == NULL)
4572     return NULL;
4573
4574   if (h != NULL && h->u.stub_cache != NULL
4575       && h->u.stub_cache->h == h
4576       && h->u.stub_cache->group == group)
4577     {
4578       stub_entry = h->u.stub_cache;
4579     }
4580   else
4581     {
4582       char *stub_name;
4583
4584       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4585       if (stub_name == NULL)
4586         return NULL;
4587
4588       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4589                                          stub_name, FALSE, FALSE);
4590       if (h != NULL)
4591         h->u.stub_cache = stub_entry;
4592
4593       free (stub_name);
4594     }
4595
4596   return stub_entry;
4597 }
4598
4599 /* Add a new stub entry to the stub hash.  Not all fields of the new
4600    stub entry are initialised.  */
4601
4602 static struct ppc_stub_hash_entry *
4603 ppc_add_stub (const char *stub_name,
4604               asection *section,
4605               struct bfd_link_info *info)
4606 {
4607   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4608   struct map_stub *group;
4609   asection *link_sec;
4610   asection *stub_sec;
4611   struct ppc_stub_hash_entry *stub_entry;
4612
4613   group = htab->sec_info[section->id].u.group;
4614   link_sec = group->link_sec;
4615   stub_sec = group->stub_sec;
4616   if (stub_sec == NULL)
4617     {
4618       size_t namelen;
4619       bfd_size_type len;
4620       char *s_name;
4621
4622       namelen = strlen (link_sec->name);
4623       len = namelen + sizeof (STUB_SUFFIX);
4624       s_name = bfd_alloc (htab->params->stub_bfd, len);
4625       if (s_name == NULL)
4626         return NULL;
4627
4628       memcpy (s_name, link_sec->name, namelen);
4629       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4630       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4631       if (stub_sec == NULL)
4632         return NULL;
4633       group->stub_sec = stub_sec;
4634     }
4635
4636   /* Enter this entry into the linker stub hash table.  */
4637   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4638                                      TRUE, FALSE);
4639   if (stub_entry == NULL)
4640     {
4641       /* xgettext:c-format */
4642       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4643                               section->owner, stub_name);
4644       return NULL;
4645     }
4646
4647   stub_entry->group = group;
4648   stub_entry->stub_offset = 0;
4649   return stub_entry;
4650 }
4651
4652 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4653    not already done.  */
4654
4655 static bfd_boolean
4656 create_got_section (bfd *abfd, struct bfd_link_info *info)
4657 {
4658   asection *got, *relgot;
4659   flagword flags;
4660   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4661
4662   if (!is_ppc64_elf (abfd))
4663     return FALSE;
4664   if (htab == NULL)
4665     return FALSE;
4666
4667   if (!htab->elf.sgot
4668       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4669     return FALSE;
4670
4671   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4672            | SEC_LINKER_CREATED);
4673
4674   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4675   if (!got
4676       || !bfd_set_section_alignment (abfd, got, 3))
4677     return FALSE;
4678
4679   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4680                                                flags | SEC_READONLY);
4681   if (!relgot
4682       || ! bfd_set_section_alignment (abfd, relgot, 3))
4683     return FALSE;
4684
4685   ppc64_elf_tdata (abfd)->got = got;
4686   ppc64_elf_tdata (abfd)->relgot = relgot;
4687   return TRUE;
4688 }
4689
4690 /* Follow indirect and warning symbol links.  */
4691
4692 static inline struct bfd_link_hash_entry *
4693 follow_link (struct bfd_link_hash_entry *h)
4694 {
4695   while (h->type == bfd_link_hash_indirect
4696          || h->type == bfd_link_hash_warning)
4697     h = h->u.i.link;
4698   return h;
4699 }
4700
4701 static inline struct elf_link_hash_entry *
4702 elf_follow_link (struct elf_link_hash_entry *h)
4703 {
4704   return (struct elf_link_hash_entry *) follow_link (&h->root);
4705 }
4706
4707 static inline struct ppc_link_hash_entry *
4708 ppc_follow_link (struct ppc_link_hash_entry *h)
4709 {
4710   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4711 }
4712
4713 /* Merge PLT info on FROM with that on TO.  */
4714
4715 static void
4716 move_plt_plist (struct ppc_link_hash_entry *from,
4717                 struct ppc_link_hash_entry *to)
4718 {
4719   if (from->elf.plt.plist != NULL)
4720     {
4721       if (to->elf.plt.plist != NULL)
4722         {
4723           struct plt_entry **entp;
4724           struct plt_entry *ent;
4725
4726           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4727             {
4728               struct plt_entry *dent;
4729
4730               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4731                 if (dent->addend == ent->addend)
4732                   {
4733                     dent->plt.refcount += ent->plt.refcount;
4734                     *entp = ent->next;
4735                     break;
4736                   }
4737               if (dent == NULL)
4738                 entp = &ent->next;
4739             }
4740           *entp = to->elf.plt.plist;
4741         }
4742
4743       to->elf.plt.plist = from->elf.plt.plist;
4744       from->elf.plt.plist = NULL;
4745     }
4746 }
4747
4748 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4749
4750 static void
4751 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4752                                 struct elf_link_hash_entry *dir,
4753                                 struct elf_link_hash_entry *ind)
4754 {
4755   struct ppc_link_hash_entry *edir, *eind;
4756
4757   edir = (struct ppc_link_hash_entry *) dir;
4758   eind = (struct ppc_link_hash_entry *) ind;
4759
4760   edir->is_func |= eind->is_func;
4761   edir->is_func_descriptor |= eind->is_func_descriptor;
4762   edir->tls_mask |= eind->tls_mask;
4763   if (eind->oh != NULL)
4764     edir->oh = ppc_follow_link (eind->oh);
4765
4766   /* If called to transfer flags for a weakdef during processing
4767      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4768      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4769   if (!(ELIMINATE_COPY_RELOCS
4770         && eind->elf.root.type != bfd_link_hash_indirect
4771         && edir->elf.dynamic_adjusted))
4772     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4773
4774   if (edir->elf.versioned != versioned_hidden)
4775     edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4776   edir->elf.ref_regular |= eind->elf.ref_regular;
4777   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4778   edir->elf.needs_plt |= eind->elf.needs_plt;
4779   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4780
4781   /* If we were called to copy over info for a weak sym, don't copy
4782      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4783      in order to simplify readonly_dynrelocs and save a field in the
4784      symbol hash entry, but that means dyn_relocs can't be used in any
4785      tests about a specific symbol, or affect other symbol flags which
4786      are then tested.
4787      Chain weakdefs so we can get from the weakdef back to an alias.
4788      The list is circular so that we don't need to use u.weakdef as
4789      well as this list to look at all aliases.  */
4790   if (eind->elf.root.type != bfd_link_hash_indirect)
4791     {
4792       struct ppc_link_hash_entry *cur, *add, *next;
4793
4794       add = eind;
4795       do
4796         {
4797           cur = edir->weakref;
4798           if (cur != NULL)
4799             {
4800               do
4801                 {
4802                   /* We can be called twice for the same symbols.
4803                      Don't make multiple loops.  */
4804                   if (cur == add)
4805                     return;
4806                   cur = cur->weakref;
4807                 } while (cur != edir);
4808             }
4809           next = add->weakref;
4810           if (cur != add)
4811             {
4812               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4813               edir->weakref = add;
4814             }
4815           add = next;
4816         } while (add != NULL && add != eind);
4817       return;
4818     }
4819
4820   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4821   if (eind->dyn_relocs != NULL)
4822     {
4823       if (edir->dyn_relocs != NULL)
4824         {
4825           struct elf_dyn_relocs **pp;
4826           struct elf_dyn_relocs *p;
4827
4828           /* Add reloc counts against the indirect sym to the direct sym
4829              list.  Merge any entries against the same section.  */
4830           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4831             {
4832               struct elf_dyn_relocs *q;
4833
4834               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4835                 if (q->sec == p->sec)
4836                   {
4837                     q->pc_count += p->pc_count;
4838                     q->count += p->count;
4839                     *pp = p->next;
4840                     break;
4841                   }
4842               if (q == NULL)
4843                 pp = &p->next;
4844             }
4845           *pp = edir->dyn_relocs;
4846         }
4847
4848       edir->dyn_relocs = eind->dyn_relocs;
4849       eind->dyn_relocs = NULL;
4850     }
4851
4852   /* Copy over got entries that we may have already seen to the
4853      symbol which just became indirect.  */
4854   if (eind->elf.got.glist != NULL)
4855     {
4856       if (edir->elf.got.glist != NULL)
4857         {
4858           struct got_entry **entp;
4859           struct got_entry *ent;
4860
4861           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4862             {
4863               struct got_entry *dent;
4864
4865               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4866                 if (dent->addend == ent->addend
4867                     && dent->owner == ent->owner
4868                     && dent->tls_type == ent->tls_type)
4869                   {
4870                     dent->got.refcount += ent->got.refcount;
4871                     *entp = ent->next;
4872                     break;
4873                   }
4874               if (dent == NULL)
4875                 entp = &ent->next;
4876             }
4877           *entp = edir->elf.got.glist;
4878         }
4879
4880       edir->elf.got.glist = eind->elf.got.glist;
4881       eind->elf.got.glist = NULL;
4882     }
4883
4884   /* And plt entries.  */
4885   move_plt_plist (eind, edir);
4886
4887   if (eind->elf.dynindx != -1)
4888     {
4889       if (edir->elf.dynindx != -1)
4890         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4891                                 edir->elf.dynstr_index);
4892       edir->elf.dynindx = eind->elf.dynindx;
4893       edir->elf.dynstr_index = eind->elf.dynstr_index;
4894       eind->elf.dynindx = -1;
4895       eind->elf.dynstr_index = 0;
4896     }
4897 }
4898
4899 /* Find the function descriptor hash entry from the given function code
4900    hash entry FH.  Link the entries via their OH fields.  */
4901
4902 static struct ppc_link_hash_entry *
4903 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4904 {
4905   struct ppc_link_hash_entry *fdh = fh->oh;
4906
4907   if (fdh == NULL)
4908     {
4909       const char *fd_name = fh->elf.root.root.string + 1;
4910
4911       fdh = (struct ppc_link_hash_entry *)
4912         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4913       if (fdh == NULL)
4914         return fdh;
4915
4916       fdh->is_func_descriptor = 1;
4917       fdh->oh = fh;
4918       fh->is_func = 1;
4919       fh->oh = fdh;
4920     }
4921
4922   fdh = ppc_follow_link (fdh);
4923   fdh->is_func_descriptor = 1;
4924   fdh->oh = fh;
4925   return fdh;
4926 }
4927
4928 /* Make a fake function descriptor sym for the undefined code sym FH.  */
4929
4930 static struct ppc_link_hash_entry *
4931 make_fdh (struct bfd_link_info *info,
4932           struct ppc_link_hash_entry *fh)
4933 {
4934   bfd *abfd = fh->elf.root.u.undef.abfd;
4935   struct bfd_link_hash_entry *bh = NULL;
4936   struct ppc_link_hash_entry *fdh;
4937   flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4938                     ? BSF_WEAK
4939                     : BSF_GLOBAL);
4940
4941   if (!_bfd_generic_link_add_one_symbol (info, abfd,
4942                                          fh->elf.root.root.string + 1,
4943                                          flags, bfd_und_section_ptr, 0,
4944                                          NULL, FALSE, FALSE, &bh))
4945     return NULL;
4946
4947   fdh = (struct ppc_link_hash_entry *) bh;
4948   fdh->elf.non_elf = 0;
4949   fdh->fake = 1;
4950   fdh->is_func_descriptor = 1;
4951   fdh->oh = fh;
4952   fh->is_func = 1;
4953   fh->oh = fdh;
4954   return fdh;
4955 }
4956
4957 /* Fix function descriptor symbols defined in .opd sections to be
4958    function type.  */
4959
4960 static bfd_boolean
4961 ppc64_elf_add_symbol_hook (bfd *ibfd,
4962                            struct bfd_link_info *info,
4963                            Elf_Internal_Sym *isym,
4964                            const char **name,
4965                            flagword *flags ATTRIBUTE_UNUSED,
4966                            asection **sec,
4967                            bfd_vma *value)
4968 {
4969   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4970       && (ibfd->flags & DYNAMIC) == 0
4971       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4972     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4973
4974   if (*sec != NULL
4975       && strcmp ((*sec)->name, ".opd") == 0)
4976     {
4977       asection *code_sec;
4978
4979       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4980             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4981         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4982
4983       /* If the symbol is a function defined in .opd, and the function
4984          code is in a discarded group, let it appear to be undefined.  */
4985       if (!bfd_link_relocatable (info)
4986           && (*sec)->reloc_count != 0
4987           && opd_entry_value (*sec, *value, &code_sec, NULL,
4988                               FALSE) != (bfd_vma) -1
4989           && discarded_section (code_sec))
4990         {
4991           *sec = bfd_und_section_ptr;
4992           isym->st_shndx = SHN_UNDEF;
4993         }
4994     }
4995   else if (*sec != NULL
4996            && strcmp ((*sec)->name, ".toc") == 0
4997            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4998     {
4999       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5000       if (htab != NULL)
5001         htab->params->object_in_toc = 1;
5002     }
5003
5004   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5005     {
5006       if (abiversion (ibfd) == 0)
5007         set_abiversion (ibfd, 2);
5008       else if (abiversion (ibfd) == 1)
5009         {
5010           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
5011                                     " for ABI version 1\n"), name);
5012           bfd_set_error (bfd_error_bad_value);
5013           return FALSE;
5014         }
5015     }
5016
5017   return TRUE;
5018 }
5019
5020 /* Merge non-visibility st_other attributes: local entry point.  */
5021
5022 static void
5023 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5024                                   const Elf_Internal_Sym *isym,
5025                                   bfd_boolean definition,
5026                                   bfd_boolean dynamic)
5027 {
5028   if (definition && (!dynamic || !h->def_regular))
5029     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5030                 | ELF_ST_VISIBILITY (h->other));
5031 }
5032
5033 /* Hook called on merging a symbol.  We use this to clear "fake" since
5034    we now have a real symbol.  */
5035
5036 static bfd_boolean
5037 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5038                         const Elf_Internal_Sym *isym,
5039                         asection **psec ATTRIBUTE_UNUSED,
5040                         bfd_boolean newdef ATTRIBUTE_UNUSED,
5041                         bfd_boolean olddef ATTRIBUTE_UNUSED,
5042                         bfd *oldbfd ATTRIBUTE_UNUSED,
5043                         const asection *oldsec ATTRIBUTE_UNUSED)
5044 {
5045   ((struct ppc_link_hash_entry *) h)->fake = 0;
5046   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5047     ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5048   return TRUE;
5049 }
5050
5051 /* This function makes an old ABI object reference to ".bar" cause the
5052    inclusion of a new ABI object archive that defines "bar".
5053    NAME is a symbol defined in an archive.  Return a symbol in the hash
5054    table that might be satisfied by the archive symbols.  */
5055
5056 static struct elf_link_hash_entry *
5057 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5058                                  struct bfd_link_info *info,
5059                                  const char *name)
5060 {
5061   struct elf_link_hash_entry *h;
5062   char *dot_name;
5063   size_t len;
5064
5065   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5066   if (h != NULL
5067       /* Don't return this sym if it is a fake function descriptor
5068          created by add_symbol_adjust.  */
5069       && !((struct ppc_link_hash_entry *) h)->fake)
5070     return h;
5071
5072   if (name[0] == '.')
5073     return h;
5074
5075   len = strlen (name);
5076   dot_name = bfd_alloc (abfd, len + 2);
5077   if (dot_name == NULL)
5078     return (struct elf_link_hash_entry *) 0 - 1;
5079   dot_name[0] = '.';
5080   memcpy (dot_name + 1, name, len + 1);
5081   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5082   bfd_release (abfd, dot_name);
5083   return h;
5084 }
5085
5086 /* This function satisfies all old ABI object references to ".bar" if a
5087    new ABI object defines "bar".  Well, at least, undefined dot symbols
5088    are made weak.  This stops later archive searches from including an
5089    object if we already have a function descriptor definition.  It also
5090    prevents the linker complaining about undefined symbols.
5091    We also check and correct mismatched symbol visibility here.  The
5092    most restrictive visibility of the function descriptor and the
5093    function entry symbol is used.  */
5094
5095 static bfd_boolean
5096 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5097 {
5098   struct ppc_link_hash_table *htab;
5099   struct ppc_link_hash_entry *fdh;
5100
5101   if (eh->elf.root.type == bfd_link_hash_warning)
5102     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5103
5104   if (eh->elf.root.type == bfd_link_hash_indirect)
5105     return TRUE;
5106
5107   if (eh->elf.root.root.string[0] != '.')
5108     abort ();
5109
5110   htab = ppc_hash_table (info);
5111   if (htab == NULL)
5112     return FALSE;
5113
5114   fdh = lookup_fdh (eh, htab);
5115   if (fdh == NULL
5116       && !bfd_link_relocatable (info)
5117       && (eh->elf.root.type == bfd_link_hash_undefined
5118           || eh->elf.root.type == bfd_link_hash_undefweak)
5119       && eh->elf.ref_regular)
5120     {
5121       /* Make an undefined function descriptor sym, in order to
5122          pull in an --as-needed shared lib.  Archives are handled
5123          elsewhere.  */
5124       fdh = make_fdh (info, eh);
5125       if (fdh == NULL)
5126         return FALSE;
5127     }
5128
5129   if (fdh != NULL)
5130     {
5131       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5132       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5133
5134       /* Make both descriptor and entry symbol have the most
5135          constraining visibility of either symbol.  */
5136       if (entry_vis < descr_vis)
5137         fdh->elf.other += entry_vis - descr_vis;
5138       else if (entry_vis > descr_vis)
5139         eh->elf.other += descr_vis - entry_vis;
5140
5141       /* Propagate reference flags from entry symbol to function
5142          descriptor symbol.  */
5143       fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5144       fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5145       fdh->elf.ref_regular |= eh->elf.ref_regular;
5146       fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5147
5148       if (!fdh->elf.forced_local
5149           && fdh->elf.dynindx == -1
5150           && fdh->elf.versioned != versioned_hidden
5151           && (bfd_link_dll (info)
5152               || fdh->elf.def_dynamic
5153               || fdh->elf.ref_dynamic)
5154           && (eh->elf.ref_regular
5155               || eh->elf.def_regular))
5156         {
5157           if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5158             return FALSE;
5159         }
5160     }
5161
5162   return TRUE;
5163 }
5164
5165 /* Set up opd section info and abiversion for IBFD, and process list
5166    of dot-symbols we made in link_hash_newfunc.  */
5167
5168 static bfd_boolean
5169 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5170 {
5171   struct ppc_link_hash_table *htab;
5172   struct ppc_link_hash_entry **p, *eh;
5173   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5174
5175   if (opd != NULL && opd->size != 0)
5176     {
5177       BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5178       ppc64_elf_section_data (opd)->sec_type = sec_opd;
5179
5180       if (abiversion (ibfd) == 0)
5181         set_abiversion (ibfd, 1);
5182       else if (abiversion (ibfd) >= 2)
5183         {
5184           /* xgettext:c-format */
5185           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5186                                     " version %d\n"),
5187                                   ibfd, abiversion (ibfd));
5188           bfd_set_error (bfd_error_bad_value);
5189           return FALSE;
5190         }
5191     }
5192
5193   if (is_ppc64_elf (info->output_bfd))
5194     {
5195       /* For input files without an explicit abiversion in e_flags
5196          we should have flagged any with symbol st_other bits set
5197          as ELFv1 and above flagged those with .opd as ELFv2.
5198          Set the output abiversion if not yet set, and for any input
5199          still ambiguous, take its abiversion from the output.
5200          Differences in ABI are reported later.  */
5201       if (abiversion (info->output_bfd) == 0)
5202         set_abiversion (info->output_bfd, abiversion (ibfd));
5203       else if (abiversion (ibfd) == 0)
5204         set_abiversion (ibfd, abiversion (info->output_bfd));
5205     }
5206
5207   htab = ppc_hash_table (info);
5208   if (htab == NULL)
5209     return TRUE;
5210
5211   if (opd != NULL && opd->size != 0
5212       && (ibfd->flags & DYNAMIC) == 0
5213       && (opd->flags & SEC_RELOC) != 0
5214       && opd->reloc_count != 0
5215       && !bfd_is_abs_section (opd->output_section)
5216       && info->gc_sections)
5217     {
5218       /* Garbage collection needs some extra help with .opd sections.
5219          We don't want to necessarily keep everything referenced by
5220          relocs in .opd, as that would keep all functions.  Instead,
5221          if we reference an .opd symbol (a function descriptor), we
5222          want to keep the function code symbol's section.  This is
5223          easy for global symbols, but for local syms we need to keep
5224          information about the associated function section.  */
5225       bfd_size_type amt;
5226       asection **opd_sym_map;
5227       Elf_Internal_Shdr *symtab_hdr;
5228       Elf_Internal_Rela *relocs, *rel_end, *rel;
5229
5230       amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5231       opd_sym_map = bfd_zalloc (ibfd, amt);
5232       if (opd_sym_map == NULL)
5233         return FALSE;
5234       ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5235       relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5236                                           info->keep_memory);
5237       if (relocs == NULL)
5238         return FALSE;
5239       symtab_hdr = &elf_symtab_hdr (ibfd);
5240       rel_end = relocs + opd->reloc_count - 1;
5241       for (rel = relocs; rel < rel_end; rel++)
5242         {
5243           enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5244           unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5245
5246           if (r_type == R_PPC64_ADDR64
5247               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5248               && r_symndx < symtab_hdr->sh_info)
5249             {
5250               Elf_Internal_Sym *isym;
5251               asection *s;
5252
5253               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5254               if (isym == NULL)
5255                 {
5256                   if (elf_section_data (opd)->relocs != relocs)
5257                     free (relocs);
5258                   return FALSE;
5259                 }
5260
5261               s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5262               if (s != NULL && s != opd)
5263                 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5264             }
5265         }
5266       if (elf_section_data (opd)->relocs != relocs)
5267         free (relocs);
5268     }
5269
5270   p = &htab->dot_syms;
5271   while ((eh = *p) != NULL)
5272     {
5273       *p = NULL;
5274       if (&eh->elf == htab->elf.hgot)
5275         ;
5276       else if (htab->elf.hgot == NULL
5277                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5278         htab->elf.hgot = &eh->elf;
5279       else if (abiversion (ibfd) <= 1)
5280         {
5281           htab->need_func_desc_adj = 1;
5282           if (!add_symbol_adjust (eh, info))
5283             return FALSE;
5284         }
5285       p = &eh->u.next_dot_sym;
5286     }
5287   return TRUE;
5288 }
5289
5290 /* Undo hash table changes when an --as-needed input file is determined
5291    not to be needed.  */
5292
5293 static bfd_boolean
5294 ppc64_elf_notice_as_needed (bfd *ibfd,
5295                             struct bfd_link_info *info,
5296                             enum notice_asneeded_action act)
5297 {
5298   if (act == notice_not_needed)
5299     {
5300       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5301
5302       if (htab == NULL)
5303         return FALSE;
5304
5305       htab->dot_syms = NULL;
5306     }
5307   return _bfd_elf_notice_as_needed (ibfd, info, act);
5308 }
5309
5310 /* If --just-symbols against a final linked binary, then assume we need
5311    toc adjusting stubs when calling functions defined there.  */
5312
5313 static void
5314 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5315 {
5316   if ((sec->flags & SEC_CODE) != 0
5317       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5318       && is_ppc64_elf (sec->owner))
5319     {
5320       if (abiversion (sec->owner) >= 2
5321           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5322         sec->has_toc_reloc = 1;
5323     }
5324   _bfd_elf_link_just_syms (sec, info);
5325 }
5326
5327 static struct plt_entry **
5328 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5329                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5330 {
5331   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5332   struct plt_entry **local_plt;
5333   unsigned char *local_got_tls_masks;
5334
5335   if (local_got_ents == NULL)
5336     {
5337       bfd_size_type size = symtab_hdr->sh_info;
5338
5339       size *= (sizeof (*local_got_ents)
5340                + sizeof (*local_plt)
5341                + sizeof (*local_got_tls_masks));
5342       local_got_ents = bfd_zalloc (abfd, size);
5343       if (local_got_ents == NULL)
5344         return NULL;
5345       elf_local_got_ents (abfd) = local_got_ents;
5346     }
5347
5348   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5349     {
5350       struct got_entry *ent;
5351
5352       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5353         if (ent->addend == r_addend
5354             && ent->owner == abfd
5355             && ent->tls_type == tls_type)
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 = local_got_ents[r_symndx];
5364           ent->addend = r_addend;
5365           ent->owner = abfd;
5366           ent->tls_type = tls_type;
5367           ent->is_indirect = FALSE;
5368           ent->got.refcount = 0;
5369           local_got_ents[r_symndx] = ent;
5370         }
5371       ent->got.refcount += 1;
5372     }
5373
5374   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5375   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5376   local_got_tls_masks[r_symndx] |= tls_type;
5377
5378   return local_plt + r_symndx;
5379 }
5380
5381 static bfd_boolean
5382 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5383 {
5384   struct plt_entry *ent;
5385
5386   for (ent = *plist; ent != NULL; ent = ent->next)
5387     if (ent->addend == addend)
5388       break;
5389   if (ent == NULL)
5390     {
5391       bfd_size_type amt = sizeof (*ent);
5392       ent = bfd_alloc (abfd, amt);
5393       if (ent == NULL)
5394         return FALSE;
5395       ent->next = *plist;
5396       ent->addend = addend;
5397       ent->plt.refcount = 0;
5398       *plist = ent;
5399     }
5400   ent->plt.refcount += 1;
5401   return TRUE;
5402 }
5403
5404 static bfd_boolean
5405 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5406 {
5407   return (r_type == R_PPC64_REL24
5408           || r_type == R_PPC64_REL14
5409           || r_type == R_PPC64_REL14_BRTAKEN
5410           || r_type == R_PPC64_REL14_BRNTAKEN
5411           || r_type == R_PPC64_ADDR24
5412           || r_type == R_PPC64_ADDR14
5413           || r_type == R_PPC64_ADDR14_BRTAKEN
5414           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5415 }
5416
5417 /* Look through the relocs for a section during the first phase, and
5418    calculate needed space in the global offset table, procedure
5419    linkage table, and dynamic reloc sections.  */
5420
5421 static bfd_boolean
5422 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5423                         asection *sec, const Elf_Internal_Rela *relocs)
5424 {
5425   struct ppc_link_hash_table *htab;
5426   Elf_Internal_Shdr *symtab_hdr;
5427   struct elf_link_hash_entry **sym_hashes;
5428   const Elf_Internal_Rela *rel;
5429   const Elf_Internal_Rela *rel_end;
5430   asection *sreloc;
5431   struct elf_link_hash_entry *tga, *dottga;
5432   bfd_boolean is_opd;
5433
5434   if (bfd_link_relocatable (info))
5435     return TRUE;
5436
5437   /* Don't do anything special with non-loaded, non-alloced sections.
5438      In particular, any relocs in such sections should not affect GOT
5439      and PLT reference counting (ie. we don't allow them to create GOT
5440      or PLT entries), there's no possibility or desire to optimize TLS
5441      relocs, and there's not much point in propagating relocs to shared
5442      libs that the dynamic linker won't relocate.  */
5443   if ((sec->flags & SEC_ALLOC) == 0)
5444     return TRUE;
5445
5446   BFD_ASSERT (is_ppc64_elf (abfd));
5447
5448   htab = ppc_hash_table (info);
5449   if (htab == NULL)
5450     return FALSE;
5451
5452   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5453                               FALSE, FALSE, TRUE);
5454   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5455                                  FALSE, FALSE, TRUE);
5456   symtab_hdr = &elf_symtab_hdr (abfd);
5457   sym_hashes = elf_sym_hashes (abfd);
5458   sreloc = NULL;
5459   is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5460   rel_end = relocs + sec->reloc_count;
5461   for (rel = relocs; rel < rel_end; rel++)
5462     {
5463       unsigned long r_symndx;
5464       struct elf_link_hash_entry *h;
5465       enum elf_ppc64_reloc_type r_type;
5466       int tls_type;
5467       struct _ppc64_elf_section_data *ppc64_sec;
5468       struct plt_entry **ifunc, **plt_list;
5469
5470       r_symndx = ELF64_R_SYM (rel->r_info);
5471       if (r_symndx < symtab_hdr->sh_info)
5472         h = NULL;
5473       else
5474         {
5475           struct ppc_link_hash_entry *eh;
5476
5477           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5478           h = elf_follow_link (h);
5479           eh = (struct ppc_link_hash_entry *) h;
5480
5481           /* PR15323, ref flags aren't set for references in the same
5482              object.  */
5483           h->root.non_ir_ref_regular = 1;
5484           if (eh->is_func && eh->oh != NULL)
5485             eh->oh->elf.root.non_ir_ref_regular = 1;
5486
5487           if (h == htab->elf.hgot)
5488             sec->has_toc_reloc = 1;
5489         }
5490
5491       tls_type = 0;
5492       ifunc = NULL;
5493       if (h != NULL)
5494         {
5495           if (h->type == STT_GNU_IFUNC)
5496             {
5497               h->needs_plt = 1;
5498               ifunc = &h->plt.plist;
5499             }
5500         }
5501       else
5502         {
5503           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5504                                                           abfd, r_symndx);
5505           if (isym == NULL)
5506             return FALSE;
5507
5508           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5509             {
5510               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5511                                              rel->r_addend, PLT_IFUNC);
5512               if (ifunc == NULL)
5513                 return FALSE;
5514             }
5515         }
5516
5517       r_type = ELF64_R_TYPE (rel->r_info);
5518       switch (r_type)
5519         {
5520         case R_PPC64_TLSGD:
5521         case R_PPC64_TLSLD:
5522           /* These special tls relocs tie a call to __tls_get_addr with
5523              its parameter symbol.  */
5524           break;
5525
5526         case R_PPC64_GOT_TLSLD16:
5527         case R_PPC64_GOT_TLSLD16_LO:
5528         case R_PPC64_GOT_TLSLD16_HI:
5529         case R_PPC64_GOT_TLSLD16_HA:
5530           tls_type = TLS_TLS | TLS_LD;
5531           goto dogottls;
5532
5533         case R_PPC64_GOT_TLSGD16:
5534         case R_PPC64_GOT_TLSGD16_LO:
5535         case R_PPC64_GOT_TLSGD16_HI:
5536         case R_PPC64_GOT_TLSGD16_HA:
5537           tls_type = TLS_TLS | TLS_GD;
5538           goto dogottls;
5539
5540         case R_PPC64_GOT_TPREL16_DS:
5541         case R_PPC64_GOT_TPREL16_LO_DS:
5542         case R_PPC64_GOT_TPREL16_HI:
5543         case R_PPC64_GOT_TPREL16_HA:
5544           if (bfd_link_dll (info))
5545             info->flags |= DF_STATIC_TLS;
5546           tls_type = TLS_TLS | TLS_TPREL;
5547           goto dogottls;
5548
5549         case R_PPC64_GOT_DTPREL16_DS:
5550         case R_PPC64_GOT_DTPREL16_LO_DS:
5551         case R_PPC64_GOT_DTPREL16_HI:
5552         case R_PPC64_GOT_DTPREL16_HA:
5553           tls_type = TLS_TLS | TLS_DTPREL;
5554         dogottls:
5555           sec->has_tls_reloc = 1;
5556           /* Fall through */
5557
5558         case R_PPC64_GOT16:
5559         case R_PPC64_GOT16_DS:
5560         case R_PPC64_GOT16_HA:
5561         case R_PPC64_GOT16_HI:
5562         case R_PPC64_GOT16_LO:
5563         case R_PPC64_GOT16_LO_DS:
5564           /* This symbol requires a global offset table entry.  */
5565           sec->has_toc_reloc = 1;
5566           if (r_type == R_PPC64_GOT_TLSLD16
5567               || r_type == R_PPC64_GOT_TLSGD16
5568               || r_type == R_PPC64_GOT_TPREL16_DS
5569               || r_type == R_PPC64_GOT_DTPREL16_DS
5570               || r_type == R_PPC64_GOT16
5571               || r_type == R_PPC64_GOT16_DS)
5572             {
5573               htab->do_multi_toc = 1;
5574               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5575             }
5576
5577           if (ppc64_elf_tdata (abfd)->got == NULL
5578               && !create_got_section (abfd, info))
5579             return FALSE;
5580
5581           if (h != NULL)
5582             {
5583               struct ppc_link_hash_entry *eh;
5584               struct got_entry *ent;
5585
5586               eh = (struct ppc_link_hash_entry *) h;
5587               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5588                 if (ent->addend == rel->r_addend
5589                     && ent->owner == abfd
5590                     && ent->tls_type == tls_type)
5591                   break;
5592               if (ent == NULL)
5593                 {
5594                   bfd_size_type amt = sizeof (*ent);
5595                   ent = bfd_alloc (abfd, amt);
5596                   if (ent == NULL)
5597                     return FALSE;
5598                   ent->next = eh->elf.got.glist;
5599                   ent->addend = rel->r_addend;
5600                   ent->owner = abfd;
5601                   ent->tls_type = tls_type;
5602                   ent->is_indirect = FALSE;
5603                   ent->got.refcount = 0;
5604                   eh->elf.got.glist = ent;
5605                 }
5606               ent->got.refcount += 1;
5607               eh->tls_mask |= tls_type;
5608             }
5609           else
5610             /* This is a global offset table entry for a local symbol.  */
5611             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5612                                         rel->r_addend, tls_type))
5613               return FALSE;
5614
5615           /* We may also need a plt entry if the symbol turns out to be
5616              an ifunc.  */
5617           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5618             {
5619               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5620                 return FALSE;
5621             }
5622           break;
5623
5624         case R_PPC64_PLT16_HA:
5625         case R_PPC64_PLT16_HI:
5626         case R_PPC64_PLT16_LO:
5627         case R_PPC64_PLT32:
5628         case R_PPC64_PLT64:
5629           /* This symbol requires a procedure linkage table entry.  */
5630           plt_list = ifunc;
5631           if (h != NULL)
5632             {
5633               h->needs_plt = 1;
5634               if (h->root.root.string[0] == '.'
5635                   && h->root.root.string[1] != '\0')
5636                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5637               plt_list = &h->plt.plist;
5638             }
5639           if (plt_list == NULL)
5640             {
5641               /* It does not make sense to have a procedure linkage
5642                  table entry for a non-ifunc local symbol.  */
5643               info->callbacks->einfo
5644                 /* xgettext:c-format */
5645                 (_("%H: %s reloc against local symbol\n"),
5646                  abfd, sec, rel->r_offset,
5647                  ppc64_elf_howto_table[r_type]->name);
5648               bfd_set_error (bfd_error_bad_value);
5649               return FALSE;
5650             }
5651           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5652             return FALSE;
5653           break;
5654
5655           /* The following relocations don't need to propagate the
5656              relocation if linking a shared object since they are
5657              section relative.  */
5658         case R_PPC64_SECTOFF:
5659         case R_PPC64_SECTOFF_LO:
5660         case R_PPC64_SECTOFF_HI:
5661         case R_PPC64_SECTOFF_HA:
5662         case R_PPC64_SECTOFF_DS:
5663         case R_PPC64_SECTOFF_LO_DS:
5664         case R_PPC64_DTPREL16:
5665         case R_PPC64_DTPREL16_LO:
5666         case R_PPC64_DTPREL16_HI:
5667         case R_PPC64_DTPREL16_HA:
5668         case R_PPC64_DTPREL16_DS:
5669         case R_PPC64_DTPREL16_LO_DS:
5670         case R_PPC64_DTPREL16_HIGH:
5671         case R_PPC64_DTPREL16_HIGHA:
5672         case R_PPC64_DTPREL16_HIGHER:
5673         case R_PPC64_DTPREL16_HIGHERA:
5674         case R_PPC64_DTPREL16_HIGHEST:
5675         case R_PPC64_DTPREL16_HIGHESTA:
5676           break;
5677
5678           /* Nor do these.  */
5679         case R_PPC64_REL16:
5680         case R_PPC64_REL16_LO:
5681         case R_PPC64_REL16_HI:
5682         case R_PPC64_REL16_HA:
5683         case R_PPC64_REL16DX_HA:
5684           break;
5685
5686           /* Not supported as a dynamic relocation.  */
5687         case R_PPC64_ADDR64_LOCAL:
5688           if (bfd_link_pic (info))
5689             {
5690               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5691                 ppc_howto_init ();
5692               /* xgettext:c-format */
5693               info->callbacks->einfo (_("%H: %s reloc unsupported "
5694                                         "in shared libraries and PIEs.\n"),
5695                                       abfd, sec, rel->r_offset,
5696                                       ppc64_elf_howto_table[r_type]->name);
5697               bfd_set_error (bfd_error_bad_value);
5698               return FALSE;
5699             }
5700           break;
5701
5702         case R_PPC64_TOC16:
5703         case R_PPC64_TOC16_DS:
5704           htab->do_multi_toc = 1;
5705           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5706           /* Fall through.  */
5707         case R_PPC64_TOC16_LO:
5708         case R_PPC64_TOC16_HI:
5709         case R_PPC64_TOC16_HA:
5710         case R_PPC64_TOC16_LO_DS:
5711           sec->has_toc_reloc = 1;
5712           break;
5713
5714           /* Marker reloc.  */
5715         case R_PPC64_ENTRY:
5716           break;
5717
5718           /* This relocation describes the C++ object vtable hierarchy.
5719              Reconstruct it for later use during GC.  */
5720         case R_PPC64_GNU_VTINHERIT:
5721           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5722             return FALSE;
5723           break;
5724
5725           /* This relocation describes which C++ vtable entries are actually
5726              used.  Record for later use during GC.  */
5727         case R_PPC64_GNU_VTENTRY:
5728           BFD_ASSERT (h != NULL);
5729           if (h != NULL
5730               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5731             return FALSE;
5732           break;
5733
5734         case R_PPC64_REL14:
5735         case R_PPC64_REL14_BRTAKEN:
5736         case R_PPC64_REL14_BRNTAKEN:
5737           {
5738             asection *dest = NULL;
5739
5740             /* Heuristic: If jumping outside our section, chances are
5741                we are going to need a stub.  */
5742             if (h != NULL)
5743               {
5744                 /* If the sym is weak it may be overridden later, so
5745                    don't assume we know where a weak sym lives.  */
5746                 if (h->root.type == bfd_link_hash_defined)
5747                   dest = h->root.u.def.section;
5748               }
5749             else
5750               {
5751                 Elf_Internal_Sym *isym;
5752
5753                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5754                                               abfd, r_symndx);
5755                 if (isym == NULL)
5756                   return FALSE;
5757
5758                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5759               }
5760
5761             if (dest != sec)
5762               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5763           }
5764           /* Fall through.  */
5765
5766         case R_PPC64_REL24:
5767           plt_list = ifunc;
5768           if (h != NULL)
5769             {
5770               h->needs_plt = 1;
5771               if (h->root.root.string[0] == '.'
5772                   && h->root.root.string[1] != '\0')
5773                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5774
5775               if (h == tga || h == dottga)
5776                 {
5777                   sec->has_tls_reloc = 1;
5778                   if (rel != relocs
5779                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5780                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5781                     /* We have a new-style __tls_get_addr call with
5782                        a marker reloc.  */
5783                     ;
5784                   else
5785                     /* Mark this section as having an old-style call.  */
5786                     sec->has_tls_get_addr_call = 1;
5787                 }
5788               plt_list = &h->plt.plist;
5789             }
5790
5791           /* We may need a .plt entry if the function this reloc
5792              refers to is in a shared lib.  */
5793           if (plt_list
5794               && !update_plt_info (abfd, plt_list, rel->r_addend))
5795             return FALSE;
5796           break;
5797
5798         case R_PPC64_ADDR14:
5799         case R_PPC64_ADDR14_BRNTAKEN:
5800         case R_PPC64_ADDR14_BRTAKEN:
5801         case R_PPC64_ADDR24:
5802           goto dodyn;
5803
5804         case R_PPC64_TPREL64:
5805           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5806           if (bfd_link_dll (info))
5807             info->flags |= DF_STATIC_TLS;
5808           goto dotlstoc;
5809
5810         case R_PPC64_DTPMOD64:
5811           if (rel + 1 < rel_end
5812               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5813               && rel[1].r_offset == rel->r_offset + 8)
5814             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5815           else
5816             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5817           goto dotlstoc;
5818
5819         case R_PPC64_DTPREL64:
5820           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5821           if (rel != relocs
5822               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5823               && rel[-1].r_offset == rel->r_offset - 8)
5824             /* This is the second reloc of a dtpmod, dtprel pair.
5825                Don't mark with TLS_DTPREL.  */
5826             goto dodyn;
5827
5828         dotlstoc:
5829           sec->has_tls_reloc = 1;
5830           if (h != NULL)
5831             {
5832               struct ppc_link_hash_entry *eh;
5833               eh = (struct ppc_link_hash_entry *) h;
5834               eh->tls_mask |= tls_type;
5835             }
5836           else
5837             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5838                                         rel->r_addend, tls_type))
5839               return FALSE;
5840
5841           ppc64_sec = ppc64_elf_section_data (sec);
5842           if (ppc64_sec->sec_type != sec_toc)
5843             {
5844               bfd_size_type amt;
5845
5846               /* One extra to simplify get_tls_mask.  */
5847               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5848               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5849               if (ppc64_sec->u.toc.symndx == NULL)
5850                 return FALSE;
5851               amt = sec->size * sizeof (bfd_vma) / 8;
5852               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5853               if (ppc64_sec->u.toc.add == NULL)
5854                 return FALSE;
5855               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5856               ppc64_sec->sec_type = sec_toc;
5857             }
5858           BFD_ASSERT (rel->r_offset % 8 == 0);
5859           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5860           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5861
5862           /* Mark the second slot of a GD or LD entry.
5863              -1 to indicate GD and -2 to indicate LD.  */
5864           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5865             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5866           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5867             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5868           goto dodyn;
5869
5870         case R_PPC64_TPREL16:
5871         case R_PPC64_TPREL16_LO:
5872         case R_PPC64_TPREL16_HI:
5873         case R_PPC64_TPREL16_HA:
5874         case R_PPC64_TPREL16_DS:
5875         case R_PPC64_TPREL16_LO_DS:
5876         case R_PPC64_TPREL16_HIGH:
5877         case R_PPC64_TPREL16_HIGHA:
5878         case R_PPC64_TPREL16_HIGHER:
5879         case R_PPC64_TPREL16_HIGHERA:
5880         case R_PPC64_TPREL16_HIGHEST:
5881         case R_PPC64_TPREL16_HIGHESTA:
5882           if (bfd_link_dll (info))
5883             info->flags |= DF_STATIC_TLS;
5884           goto dodyn;
5885
5886         case R_PPC64_ADDR64:
5887           if (is_opd
5888               && rel + 1 < rel_end
5889               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5890             {
5891               if (h != NULL)
5892                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5893             }
5894           /* Fall through.  */
5895
5896         case R_PPC64_ADDR16:
5897         case R_PPC64_ADDR16_DS:
5898         case R_PPC64_ADDR16_HA:
5899         case R_PPC64_ADDR16_HI:
5900         case R_PPC64_ADDR16_HIGH:
5901         case R_PPC64_ADDR16_HIGHA:
5902         case R_PPC64_ADDR16_HIGHER:
5903         case R_PPC64_ADDR16_HIGHERA:
5904         case R_PPC64_ADDR16_HIGHEST:
5905         case R_PPC64_ADDR16_HIGHESTA:
5906         case R_PPC64_ADDR16_LO:
5907         case R_PPC64_ADDR16_LO_DS:
5908           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5909               && rel->r_addend == 0)
5910             {
5911               /* We may need a .plt entry if this reloc refers to a
5912                  function in a shared lib.  */
5913               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5914                 return FALSE;
5915               h->pointer_equality_needed = 1;
5916             }
5917           /* Fall through.  */
5918
5919         case R_PPC64_REL30:
5920         case R_PPC64_REL32:
5921         case R_PPC64_REL64:
5922         case R_PPC64_ADDR32:
5923         case R_PPC64_UADDR16:
5924         case R_PPC64_UADDR32:
5925         case R_PPC64_UADDR64:
5926         case R_PPC64_TOC:
5927           if (h != NULL && !bfd_link_pic (info))
5928             /* We may need a copy reloc.  */
5929             h->non_got_ref = 1;
5930
5931           /* Don't propagate .opd relocs.  */
5932           if (NO_OPD_RELOCS && is_opd)
5933             break;
5934
5935           /* If we are creating a shared library, and this is a reloc
5936              against a global symbol, or a non PC relative reloc
5937              against a local symbol, then we need to copy the reloc
5938              into the shared library.  However, if we are linking with
5939              -Bsymbolic, we do not need to copy a reloc against a
5940              global symbol which is defined in an object we are
5941              including in the link (i.e., DEF_REGULAR is set).  At
5942              this point we have not seen all the input files, so it is
5943              possible that DEF_REGULAR is not set now but will be set
5944              later (it is never cleared).  In case of a weak definition,
5945              DEF_REGULAR may be cleared later by a strong definition in
5946              a shared library.  We account for that possibility below by
5947              storing information in the dyn_relocs field of the hash
5948              table entry.  A similar situation occurs when creating
5949              shared libraries and symbol visibility changes render the
5950              symbol local.
5951
5952              If on the other hand, we are creating an executable, we
5953              may need to keep relocations for symbols satisfied by a
5954              dynamic library if we manage to avoid copy relocs for the
5955              symbol.  */
5956         dodyn:
5957           if ((bfd_link_pic (info)
5958                && (must_be_dyn_reloc (info, r_type)
5959                    || (h != NULL
5960                        && (!SYMBOLIC_BIND (info, h)
5961                            || h->root.type == bfd_link_hash_defweak
5962                            || !h->def_regular))))
5963               || (ELIMINATE_COPY_RELOCS
5964                   && !bfd_link_pic (info)
5965                   && h != NULL
5966                   && (h->root.type == bfd_link_hash_defweak
5967                       || !h->def_regular))
5968               || (!bfd_link_pic (info)
5969                   && ifunc != NULL))
5970             {
5971               /* We must copy these reloc types into the output file.
5972                  Create a reloc section in dynobj and make room for
5973                  this reloc.  */
5974               if (sreloc == NULL)
5975                 {
5976                   sreloc = _bfd_elf_make_dynamic_reloc_section
5977                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5978
5979                   if (sreloc == NULL)
5980                     return FALSE;
5981                 }
5982
5983               /* If this is a global symbol, we count the number of
5984                  relocations we need for this symbol.  */
5985               if (h != NULL)
5986                 {
5987                   struct elf_dyn_relocs *p;
5988                   struct elf_dyn_relocs **head;
5989
5990                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5991                   p = *head;
5992                   if (p == NULL || p->sec != sec)
5993                     {
5994                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5995                       if (p == NULL)
5996                         return FALSE;
5997                       p->next = *head;
5998                       *head = p;
5999                       p->sec = sec;
6000                       p->count = 0;
6001                       p->pc_count = 0;
6002                     }
6003                   p->count += 1;
6004                   if (!must_be_dyn_reloc (info, r_type))
6005                     p->pc_count += 1;
6006                 }
6007               else
6008                 {
6009                   /* Track dynamic relocs needed for local syms too.
6010                      We really need local syms available to do this
6011                      easily.  Oh well.  */
6012                   struct ppc_dyn_relocs *p;
6013                   struct ppc_dyn_relocs **head;
6014                   bfd_boolean is_ifunc;
6015                   asection *s;
6016                   void *vpp;
6017                   Elf_Internal_Sym *isym;
6018
6019                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6020                                                 abfd, r_symndx);
6021                   if (isym == NULL)
6022                     return FALSE;
6023
6024                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6025                   if (s == NULL)
6026                     s = sec;
6027
6028                   vpp = &elf_section_data (s)->local_dynrel;
6029                   head = (struct ppc_dyn_relocs **) vpp;
6030                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6031                   p = *head;
6032                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6033                     p = p->next;
6034                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6035                     {
6036                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6037                       if (p == NULL)
6038                         return FALSE;
6039                       p->next = *head;
6040                       *head = p;
6041                       p->sec = sec;
6042                       p->ifunc = is_ifunc;
6043                       p->count = 0;
6044                     }
6045                   p->count += 1;
6046                 }
6047             }
6048           break;
6049
6050         default:
6051           break;
6052         }
6053     }
6054
6055   return TRUE;
6056 }
6057
6058 /* Merge backend specific data from an object file to the output
6059    object file when linking.  */
6060
6061 static bfd_boolean
6062 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6063 {
6064   bfd *obfd = info->output_bfd;
6065   unsigned long iflags, oflags;
6066
6067   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6068     return TRUE;
6069
6070   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6071     return TRUE;
6072
6073   if (!_bfd_generic_verify_endian_match (ibfd, info))
6074     return FALSE;
6075
6076   iflags = elf_elfheader (ibfd)->e_flags;
6077   oflags = elf_elfheader (obfd)->e_flags;
6078
6079   if (iflags & ~EF_PPC64_ABI)
6080     {
6081       _bfd_error_handler
6082         /* xgettext:c-format */
6083         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6084       bfd_set_error (bfd_error_bad_value);
6085       return FALSE;
6086     }
6087   else if (iflags != oflags && iflags != 0)
6088     {
6089       _bfd_error_handler
6090         /* xgettext:c-format */
6091         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6092          ibfd, iflags, oflags);
6093       bfd_set_error (bfd_error_bad_value);
6094       return FALSE;
6095     }
6096
6097   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6098
6099   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6100   _bfd_elf_merge_object_attributes (ibfd, info);
6101
6102   return TRUE;
6103 }
6104
6105 static bfd_boolean
6106 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6107 {
6108   /* Print normal ELF private data.  */
6109   _bfd_elf_print_private_bfd_data (abfd, ptr);
6110
6111   if (elf_elfheader (abfd)->e_flags != 0)
6112     {
6113       FILE *file = ptr;
6114
6115       fprintf (file, _("private flags = 0x%lx:"),
6116                elf_elfheader (abfd)->e_flags);
6117
6118       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6119         fprintf (file, _(" [abiv%ld]"),
6120                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6121       fputc ('\n', file);
6122     }
6123
6124   return TRUE;
6125 }
6126
6127 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6128    of the code entry point, and its section, which must be in the same
6129    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6130
6131 static bfd_vma
6132 opd_entry_value (asection *opd_sec,
6133                  bfd_vma offset,
6134                  asection **code_sec,
6135                  bfd_vma *code_off,
6136                  bfd_boolean in_code_sec)
6137 {
6138   bfd *opd_bfd = opd_sec->owner;
6139   Elf_Internal_Rela *relocs;
6140   Elf_Internal_Rela *lo, *hi, *look;
6141   bfd_vma val;
6142
6143   /* No relocs implies we are linking a --just-symbols object, or looking
6144      at a final linked executable with addr2line or somesuch.  */
6145   if (opd_sec->reloc_count == 0)
6146     {
6147       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6148
6149       if (contents == NULL)
6150         {
6151           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6152             return (bfd_vma) -1;
6153           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6154         }
6155
6156       /* PR 17512: file: 64b9dfbb.  */
6157       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6158         return (bfd_vma) -1;
6159
6160       val = bfd_get_64 (opd_bfd, contents + offset);
6161       if (code_sec != NULL)
6162         {
6163           asection *sec, *likely = NULL;
6164
6165           if (in_code_sec)
6166             {
6167               sec = *code_sec;
6168               if (sec->vma <= val
6169                   && val < sec->vma + sec->size)
6170                 likely = sec;
6171               else
6172                 val = -1;
6173             }
6174           else
6175             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6176               if (sec->vma <= val
6177                   && (sec->flags & SEC_LOAD) != 0
6178                   && (sec->flags & SEC_ALLOC) != 0)
6179                 likely = sec;
6180           if (likely != NULL)
6181             {
6182               *code_sec = likely;
6183               if (code_off != NULL)
6184                 *code_off = val - likely->vma;
6185             }
6186         }
6187       return val;
6188     }
6189
6190   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6191
6192   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6193   if (relocs == NULL)
6194     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6195   /* PR 17512: file: df8e1fd6.  */
6196   if (relocs == NULL)
6197     return (bfd_vma) -1;
6198
6199   /* Go find the opd reloc at the sym address.  */
6200   lo = relocs;
6201   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6202   val = (bfd_vma) -1;
6203   while (lo < hi)
6204     {
6205       look = lo + (hi - lo) / 2;
6206       if (look->r_offset < offset)
6207         lo = look + 1;
6208       else if (look->r_offset > offset)
6209         hi = look;
6210       else
6211         {
6212           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6213
6214           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6215               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6216             {
6217               unsigned long symndx = ELF64_R_SYM (look->r_info);
6218               asection *sec = NULL;
6219
6220               if (symndx >= symtab_hdr->sh_info
6221                   && elf_sym_hashes (opd_bfd) != NULL)
6222                 {
6223                   struct elf_link_hash_entry **sym_hashes;
6224                   struct elf_link_hash_entry *rh;
6225
6226                   sym_hashes = elf_sym_hashes (opd_bfd);
6227                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6228                   if (rh != NULL)
6229                     {
6230                       rh = elf_follow_link (rh);
6231                       if (rh->root.type != bfd_link_hash_defined
6232                           && rh->root.type != bfd_link_hash_defweak)
6233                         break;
6234                       if (rh->root.u.def.section->owner == opd_bfd)
6235                         {
6236                           val = rh->root.u.def.value;
6237                           sec = rh->root.u.def.section;
6238                         }
6239                     }
6240                 }
6241
6242               if (sec == NULL)
6243                 {
6244                   Elf_Internal_Sym *sym;
6245
6246                   if (symndx < symtab_hdr->sh_info)
6247                     {
6248                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6249                       if (sym == NULL)
6250                         {
6251                           size_t symcnt = symtab_hdr->sh_info;
6252                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6253                                                       symcnt, 0,
6254                                                       NULL, NULL, NULL);
6255                           if (sym == NULL)
6256                             break;
6257                           symtab_hdr->contents = (bfd_byte *) sym;
6258                         }
6259                       sym += symndx;
6260                     }
6261                   else
6262                     {
6263                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6264                                                   1, symndx,
6265                                                   NULL, NULL, NULL);
6266                       if (sym == NULL)
6267                         break;
6268                     }
6269                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6270                   if (sec == NULL)
6271                     break;
6272                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6273                   val = sym->st_value;
6274                 }
6275
6276               val += look->r_addend;
6277               if (code_off != NULL)
6278                 *code_off = val;
6279               if (code_sec != NULL)
6280                 {
6281                   if (in_code_sec && *code_sec != sec)
6282                     return -1;
6283                   else
6284                     *code_sec = sec;
6285                 }
6286               if (sec->output_section != NULL)
6287                 val += sec->output_section->vma + sec->output_offset;
6288             }
6289           break;
6290         }
6291     }
6292
6293   return val;
6294 }
6295
6296 /* If the ELF symbol SYM might be a function in SEC, return the
6297    function size and set *CODE_OFF to the function's entry point,
6298    otherwise return zero.  */
6299
6300 static bfd_size_type
6301 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6302                               bfd_vma *code_off)
6303 {
6304   bfd_size_type size;
6305
6306   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6307                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6308     return 0;
6309
6310   size = 0;
6311   if (!(sym->flags & BSF_SYNTHETIC))
6312     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6313
6314   if (strcmp (sym->section->name, ".opd") == 0)
6315     {
6316       struct _opd_sec_data *opd = get_opd_info (sym->section);
6317       bfd_vma symval = sym->value;
6318
6319       if (opd != NULL
6320           && opd->adjust != NULL
6321           && elf_section_data (sym->section)->relocs != NULL)
6322         {
6323           /* opd_entry_value will use cached relocs that have been
6324              adjusted, but with raw symbols.  That means both local
6325              and global symbols need adjusting.  */
6326           long adjust = opd->adjust[OPD_NDX (symval)];
6327           if (adjust == -1)
6328             return 0;
6329           symval += adjust;
6330         }
6331
6332       if (opd_entry_value (sym->section, symval,
6333                            &sec, code_off, TRUE) == (bfd_vma) -1)
6334         return 0;
6335       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6336          symbol.  This size has nothing to do with the code size of the
6337          function, which is what we're supposed to return, but the
6338          code size isn't available without looking up the dot-sym.
6339          However, doing that would be a waste of time particularly
6340          since elf_find_function will look at the dot-sym anyway.
6341          Now, elf_find_function will keep the largest size of any
6342          function sym found at the code address of interest, so return
6343          1 here to avoid it incorrectly caching a larger function size
6344          for a small function.  This does mean we return the wrong
6345          size for a new-ABI function of size 24, but all that does is
6346          disable caching for such functions.  */
6347       if (size == 24)
6348         size = 1;
6349     }
6350   else
6351     {
6352       if (sym->section != sec)
6353         return 0;
6354       *code_off = sym->value;
6355     }
6356   if (size == 0)
6357     size = 1;
6358   return size;
6359 }
6360
6361 /* Return true if symbol is a strong function defined in an ELFv2
6362    object with st_other localentry bits of zero, ie. its local entry
6363    point coincides with its global entry point.  */
6364
6365 static bfd_boolean
6366 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6367 {
6368   return (h != NULL
6369           && h->type == STT_FUNC
6370           && h->root.type == bfd_link_hash_defined
6371           && (STO_PPC64_LOCAL_MASK & h->other) == 0
6372           && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6373           && is_ppc64_elf (h->root.u.def.section->owner)
6374           && abiversion (h->root.u.def.section->owner) >= 2);
6375 }
6376
6377 /* Return true if symbol is defined in a regular object file.  */
6378
6379 static bfd_boolean
6380 is_static_defined (struct elf_link_hash_entry *h)
6381 {
6382   return ((h->root.type == bfd_link_hash_defined
6383            || h->root.type == bfd_link_hash_defweak)
6384           && h->root.u.def.section != NULL
6385           && h->root.u.def.section->output_section != NULL);
6386 }
6387
6388 /* If FDH is a function descriptor symbol, return the associated code
6389    entry symbol if it is defined.  Return NULL otherwise.  */
6390
6391 static struct ppc_link_hash_entry *
6392 defined_code_entry (struct ppc_link_hash_entry *fdh)
6393 {
6394   if (fdh->is_func_descriptor)
6395     {
6396       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6397       if (fh->elf.root.type == bfd_link_hash_defined
6398           || fh->elf.root.type == bfd_link_hash_defweak)
6399         return fh;
6400     }
6401   return NULL;
6402 }
6403
6404 /* If FH is a function code entry symbol, return the associated
6405    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6406
6407 static struct ppc_link_hash_entry *
6408 defined_func_desc (struct ppc_link_hash_entry *fh)
6409 {
6410   if (fh->oh != NULL
6411       && fh->oh->is_func_descriptor)
6412     {
6413       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6414       if (fdh->elf.root.type == bfd_link_hash_defined
6415           || fdh->elf.root.type == bfd_link_hash_defweak)
6416         return fdh;
6417     }
6418   return NULL;
6419 }
6420
6421 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6422
6423 /* Garbage collect sections, after first dealing with dot-symbols.  */
6424
6425 static bfd_boolean
6426 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6427 {
6428   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6429
6430   if (htab != NULL && htab->need_func_desc_adj)
6431     {
6432       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6433       htab->need_func_desc_adj = 0;
6434     }
6435   return bfd_elf_gc_sections (abfd, info);
6436 }
6437
6438 /* Mark all our entry sym sections, both opd and code section.  */
6439
6440 static void
6441 ppc64_elf_gc_keep (struct bfd_link_info *info)
6442 {
6443   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6444   struct bfd_sym_chain *sym;
6445
6446   if (htab == NULL)
6447     return;
6448
6449   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6450     {
6451       struct ppc_link_hash_entry *eh, *fh;
6452       asection *sec;
6453
6454       eh = (struct ppc_link_hash_entry *)
6455         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6456       if (eh == NULL)
6457         continue;
6458       if (eh->elf.root.type != bfd_link_hash_defined
6459           && eh->elf.root.type != bfd_link_hash_defweak)
6460         continue;
6461
6462       fh = defined_code_entry (eh);
6463       if (fh != NULL)
6464         {
6465           sec = fh->elf.root.u.def.section;
6466           sec->flags |= SEC_KEEP;
6467         }
6468       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6469                && opd_entry_value (eh->elf.root.u.def.section,
6470                                    eh->elf.root.u.def.value,
6471                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6472         sec->flags |= SEC_KEEP;
6473
6474       sec = eh->elf.root.u.def.section;
6475       sec->flags |= SEC_KEEP;
6476     }
6477 }
6478
6479 /* Mark sections containing dynamically referenced symbols.  When
6480    building shared libraries, we must assume that any visible symbol is
6481    referenced.  */
6482
6483 static bfd_boolean
6484 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6485 {
6486   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6487   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6488   struct ppc_link_hash_entry *fdh;
6489   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6490
6491   /* Dynamic linking info is on the func descriptor sym.  */
6492   fdh = defined_func_desc (eh);
6493   if (fdh != NULL)
6494     eh = fdh;
6495
6496   if ((eh->elf.root.type == bfd_link_hash_defined
6497        || eh->elf.root.type == bfd_link_hash_defweak)
6498       && (eh->elf.ref_dynamic
6499           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6500               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6501               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6502               && (!bfd_link_executable (info)
6503                   || info->gc_keep_exported
6504                   || info->export_dynamic
6505                   || (eh->elf.dynamic
6506                       && d != NULL
6507                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6508               && (eh->elf.versioned >= versioned
6509                   || !bfd_hide_sym_by_version (info->version_info,
6510                                                eh->elf.root.root.string)))))
6511     {
6512       asection *code_sec;
6513       struct ppc_link_hash_entry *fh;
6514
6515       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6516
6517       /* Function descriptor syms cause the associated
6518          function code sym section to be marked.  */
6519       fh = defined_code_entry (eh);
6520       if (fh != NULL)
6521         {
6522           code_sec = fh->elf.root.u.def.section;
6523           code_sec->flags |= SEC_KEEP;
6524         }
6525       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6526                && opd_entry_value (eh->elf.root.u.def.section,
6527                                    eh->elf.root.u.def.value,
6528                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6529         code_sec->flags |= SEC_KEEP;
6530     }
6531
6532   return TRUE;
6533 }
6534
6535 /* Return the section that should be marked against GC for a given
6536    relocation.  */
6537
6538 static asection *
6539 ppc64_elf_gc_mark_hook (asection *sec,
6540                         struct bfd_link_info *info,
6541                         Elf_Internal_Rela *rel,
6542                         struct elf_link_hash_entry *h,
6543                         Elf_Internal_Sym *sym)
6544 {
6545   asection *rsec;
6546
6547   /* Syms return NULL if we're marking .opd, so we avoid marking all
6548      function sections, as all functions are referenced in .opd.  */
6549   rsec = NULL;
6550   if (get_opd_info (sec) != NULL)
6551     return rsec;
6552
6553   if (h != NULL)
6554     {
6555       enum elf_ppc64_reloc_type r_type;
6556       struct ppc_link_hash_entry *eh, *fh, *fdh;
6557
6558       r_type = ELF64_R_TYPE (rel->r_info);
6559       switch (r_type)
6560         {
6561         case R_PPC64_GNU_VTINHERIT:
6562         case R_PPC64_GNU_VTENTRY:
6563           break;
6564
6565         default:
6566           switch (h->root.type)
6567             {
6568             case bfd_link_hash_defined:
6569             case bfd_link_hash_defweak:
6570               eh = (struct ppc_link_hash_entry *) h;
6571               fdh = defined_func_desc (eh);
6572               if (fdh != NULL)
6573                 {
6574                   /* -mcall-aixdesc code references the dot-symbol on
6575                      a call reloc.  Mark the function descriptor too
6576                      against garbage collection.  */
6577                   fdh->elf.mark = 1;
6578                   if (fdh->elf.u.weakdef != NULL)
6579                     fdh->elf.u.weakdef->mark = 1;
6580                   eh = fdh;
6581                 }
6582
6583               /* Function descriptor syms cause the associated
6584                  function code sym section to be marked.  */
6585               fh = defined_code_entry (eh);
6586               if (fh != NULL)
6587                 {
6588                   /* They also mark their opd section.  */
6589                   eh->elf.root.u.def.section->gc_mark = 1;
6590
6591                   rsec = fh->elf.root.u.def.section;
6592                 }
6593               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6594                        && opd_entry_value (eh->elf.root.u.def.section,
6595                                            eh->elf.root.u.def.value,
6596                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6597                 eh->elf.root.u.def.section->gc_mark = 1;
6598               else
6599                 rsec = h->root.u.def.section;
6600               break;
6601
6602             case bfd_link_hash_common:
6603               rsec = h->root.u.c.p->section;
6604               break;
6605
6606             default:
6607               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6608             }
6609         }
6610     }
6611   else
6612     {
6613       struct _opd_sec_data *opd;
6614
6615       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6616       opd = get_opd_info (rsec);
6617       if (opd != NULL && opd->func_sec != NULL)
6618         {
6619           rsec->gc_mark = 1;
6620
6621           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6622         }
6623     }
6624
6625   return rsec;
6626 }
6627
6628 /* The maximum size of .sfpr.  */
6629 #define SFPR_MAX (218*4)
6630
6631 struct sfpr_def_parms
6632 {
6633   const char name[12];
6634   unsigned char lo, hi;
6635   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6636   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6637 };
6638
6639 /* Auto-generate _save*, _rest* functions in .sfpr.
6640    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6641    instead.  */
6642
6643 static bfd_boolean
6644 sfpr_define (struct bfd_link_info *info,
6645              const struct sfpr_def_parms *parm,
6646              asection *stub_sec)
6647 {
6648   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6649   unsigned int i;
6650   size_t len = strlen (parm->name);
6651   bfd_boolean writing = FALSE;
6652   char sym[16];
6653
6654   if (htab == NULL)
6655     return FALSE;
6656
6657   memcpy (sym, parm->name, len);
6658   sym[len + 2] = 0;
6659
6660   for (i = parm->lo; i <= parm->hi; i++)
6661     {
6662       struct ppc_link_hash_entry *h;
6663
6664       sym[len + 0] = i / 10 + '0';
6665       sym[len + 1] = i % 10 + '0';
6666       h = (struct ppc_link_hash_entry *)
6667         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6668       if (stub_sec != NULL)
6669         {
6670           if (h != NULL
6671               && h->elf.root.type == bfd_link_hash_defined
6672               && h->elf.root.u.def.section == htab->sfpr)
6673             {
6674               struct elf_link_hash_entry *s;
6675               char buf[32];
6676               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6677               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6678               if (s == NULL)
6679                 return FALSE;
6680               if (s->root.type == bfd_link_hash_new
6681                   || (s->root.type = bfd_link_hash_defined
6682                       && s->root.u.def.section == stub_sec))
6683                 {
6684                   s->root.type = bfd_link_hash_defined;
6685                   s->root.u.def.section = stub_sec;
6686                   s->root.u.def.value = (stub_sec->size
6687                                          + h->elf.root.u.def.value);
6688                   s->ref_regular = 1;
6689                   s->def_regular = 1;
6690                   s->ref_regular_nonweak = 1;
6691                   s->forced_local = 1;
6692                   s->non_elf = 0;
6693                   s->root.linker_def = 1;
6694                 }
6695             }
6696           continue;
6697         }
6698       if (h != NULL)
6699         {
6700           h->save_res = 1;
6701           if (!h->elf.def_regular)
6702             {
6703               h->elf.root.type = bfd_link_hash_defined;
6704               h->elf.root.u.def.section = htab->sfpr;
6705               h->elf.root.u.def.value = htab->sfpr->size;
6706               h->elf.type = STT_FUNC;
6707               h->elf.def_regular = 1;
6708               h->elf.non_elf = 0;
6709               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6710               writing = TRUE;
6711               if (htab->sfpr->contents == NULL)
6712                 {
6713                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6714                   if (htab->sfpr->contents == NULL)
6715                     return FALSE;
6716                 }
6717             }
6718         }
6719       if (writing)
6720         {
6721           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6722           if (i != parm->hi)
6723             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6724           else
6725             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6726           htab->sfpr->size = p - htab->sfpr->contents;
6727         }
6728     }
6729
6730   return TRUE;
6731 }
6732
6733 static bfd_byte *
6734 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6735 {
6736   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6737   return p + 4;
6738 }
6739
6740 static bfd_byte *
6741 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6742 {
6743   p = savegpr0 (abfd, p, r);
6744   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6745   p = p + 4;
6746   bfd_put_32 (abfd, BLR, p);
6747   return p + 4;
6748 }
6749
6750 static bfd_byte *
6751 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6752 {
6753   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6754   return p + 4;
6755 }
6756
6757 static bfd_byte *
6758 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6759 {
6760   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6761   p = p + 4;
6762   p = restgpr0 (abfd, p, r);
6763   bfd_put_32 (abfd, MTLR_R0, p);
6764   p = p + 4;
6765   if (r == 29)
6766     {
6767       p = restgpr0 (abfd, p, 30);
6768       p = restgpr0 (abfd, p, 31);
6769     }
6770   bfd_put_32 (abfd, BLR, p);
6771   return p + 4;
6772 }
6773
6774 static bfd_byte *
6775 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6776 {
6777   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6778   return p + 4;
6779 }
6780
6781 static bfd_byte *
6782 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6783 {
6784   p = savegpr1 (abfd, p, r);
6785   bfd_put_32 (abfd, BLR, p);
6786   return p + 4;
6787 }
6788
6789 static bfd_byte *
6790 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6791 {
6792   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6793   return p + 4;
6794 }
6795
6796 static bfd_byte *
6797 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6798 {
6799   p = restgpr1 (abfd, p, r);
6800   bfd_put_32 (abfd, BLR, p);
6801   return p + 4;
6802 }
6803
6804 static bfd_byte *
6805 savefpr (bfd *abfd, bfd_byte *p, int r)
6806 {
6807   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6808   return p + 4;
6809 }
6810
6811 static bfd_byte *
6812 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6813 {
6814   p = savefpr (abfd, p, r);
6815   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6816   p = p + 4;
6817   bfd_put_32 (abfd, BLR, p);
6818   return p + 4;
6819 }
6820
6821 static bfd_byte *
6822 restfpr (bfd *abfd, bfd_byte *p, int r)
6823 {
6824   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6825   return p + 4;
6826 }
6827
6828 static bfd_byte *
6829 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6830 {
6831   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6832   p = p + 4;
6833   p = restfpr (abfd, p, r);
6834   bfd_put_32 (abfd, MTLR_R0, p);
6835   p = p + 4;
6836   if (r == 29)
6837     {
6838       p = restfpr (abfd, p, 30);
6839       p = restfpr (abfd, p, 31);
6840     }
6841   bfd_put_32 (abfd, BLR, p);
6842   return p + 4;
6843 }
6844
6845 static bfd_byte *
6846 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6847 {
6848   p = savefpr (abfd, p, r);
6849   bfd_put_32 (abfd, BLR, p);
6850   return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6855 {
6856   p = restfpr (abfd, p, r);
6857   bfd_put_32 (abfd, BLR, p);
6858   return p + 4;
6859 }
6860
6861 static bfd_byte *
6862 savevr (bfd *abfd, bfd_byte *p, int r)
6863 {
6864   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6865   p = p + 4;
6866   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6867   return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6872 {
6873   p = savevr (abfd, p, r);
6874   bfd_put_32 (abfd, BLR, p);
6875   return p + 4;
6876 }
6877
6878 static bfd_byte *
6879 restvr (bfd *abfd, bfd_byte *p, int r)
6880 {
6881   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6882   p = p + 4;
6883   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6884   return p + 4;
6885 }
6886
6887 static bfd_byte *
6888 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6889 {
6890   p = restvr (abfd, p, r);
6891   bfd_put_32 (abfd, BLR, p);
6892   return p + 4;
6893 }
6894
6895 /* Called via elf_link_hash_traverse to transfer dynamic linking
6896    information on function code symbol entries to their corresponding
6897    function descriptor symbol entries.  */
6898
6899 static bfd_boolean
6900 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6901 {
6902   struct bfd_link_info *info;
6903   struct ppc_link_hash_table *htab;
6904   struct ppc_link_hash_entry *fh;
6905   struct ppc_link_hash_entry *fdh;
6906   bfd_boolean force_local;
6907
6908   fh = (struct ppc_link_hash_entry *) h;
6909   if (fh->elf.root.type == bfd_link_hash_indirect)
6910     return TRUE;
6911
6912   if (!fh->is_func)
6913     return TRUE;
6914
6915   if (fh->elf.root.root.string[0] != '.'
6916       || fh->elf.root.root.string[1] == '\0')
6917     return TRUE;
6918
6919   info = inf;
6920   htab = ppc_hash_table (info);
6921   if (htab == NULL)
6922     return FALSE;
6923
6924   /* Find the corresponding function descriptor symbol.  */
6925   fdh = lookup_fdh (fh, htab);
6926
6927   /* Resolve undefined references to dot-symbols as the value
6928      in the function descriptor, if we have one in a regular object.
6929      This is to satisfy cases like ".quad .foo".  Calls to functions
6930      in dynamic objects are handled elsewhere.  */
6931   if ((fh->elf.root.type == bfd_link_hash_undefined
6932        || fh->elf.root.type == bfd_link_hash_undefweak)
6933       && (fdh->elf.root.type == bfd_link_hash_defined
6934           || fdh->elf.root.type == bfd_link_hash_defweak)
6935       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6936       && opd_entry_value (fdh->elf.root.u.def.section,
6937                           fdh->elf.root.u.def.value,
6938                           &fh->elf.root.u.def.section,
6939                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6940     {
6941       fh->elf.root.type = fdh->elf.root.type;
6942       fh->elf.forced_local = 1;
6943       fh->elf.def_regular = fdh->elf.def_regular;
6944       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6945     }
6946
6947   if (!fh->elf.dynamic)
6948     {
6949       struct plt_entry *ent;
6950
6951       for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6952         if (ent->plt.refcount > 0)
6953           break;
6954       if (ent == NULL)
6955         return TRUE;
6956     }
6957
6958   /* Create a descriptor as undefined if necessary.  */
6959   if (fdh == NULL
6960       && !bfd_link_executable (info)
6961       && (fh->elf.root.type == bfd_link_hash_undefined
6962           || fh->elf.root.type == bfd_link_hash_undefweak))
6963     {
6964       fdh = make_fdh (info, fh);
6965       if (fdh == NULL)
6966         return FALSE;
6967     }
6968
6969   /* We can't support overriding of symbols on a fake descriptor.  */
6970   if (fdh != NULL
6971       && fdh->fake
6972       && (fh->elf.root.type == bfd_link_hash_defined
6973           || fh->elf.root.type == bfd_link_hash_defweak))
6974     _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6975
6976   /* Transfer dynamic linking information to the function descriptor.  */
6977   if (fdh != NULL)
6978     {
6979       fdh->elf.ref_regular |= fh->elf.ref_regular;
6980       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6981       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6982       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6983       fdh->elf.dynamic |= fh->elf.dynamic;
6984       fdh->elf.needs_plt |= (fh->elf.needs_plt
6985                              || fh->elf.type == STT_FUNC
6986                              || fh->elf.type == STT_GNU_IFUNC);
6987       move_plt_plist (fh, fdh);
6988
6989       if (!fdh->elf.forced_local
6990           && fh->elf.dynindx != -1)
6991         if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6992           return FALSE;
6993     }
6994
6995   /* Now that the info is on the function descriptor, clear the
6996      function code sym info.  Any function code syms for which we
6997      don't have a definition in a regular file, we force local.
6998      This prevents a shared library from exporting syms that have
6999      been imported from another library.  Function code syms that
7000      are really in the library we must leave global to prevent the
7001      linker dragging in a definition from a static library.  */
7002   force_local = (!fh->elf.def_regular
7003                  || fdh == NULL
7004                  || !fdh->elf.def_regular
7005                  || fdh->elf.forced_local);
7006   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7007
7008   return TRUE;
7009 }
7010
7011 static const struct sfpr_def_parms save_res_funcs[] =
7012   {
7013     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7014     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7015     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7016     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7017     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7018     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7019     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7020     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7021     { "._savef", 14, 31, savefpr, savefpr1_tail },
7022     { "._restf", 14, 31, restfpr, restfpr1_tail },
7023     { "_savevr_", 20, 31, savevr, savevr_tail },
7024     { "_restvr_", 20, 31, restvr, restvr_tail }
7025   };
7026
7027 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7028    this hook to a) provide some gcc support functions, and b) transfer
7029    dynamic linking information gathered so far on function code symbol
7030    entries, to their corresponding function descriptor symbol entries.  */
7031
7032 static bfd_boolean
7033 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7034                             struct bfd_link_info *info)
7035 {
7036   struct ppc_link_hash_table *htab;
7037
7038   htab = ppc_hash_table (info);
7039   if (htab == NULL)
7040     return FALSE;
7041
7042   /* Provide any missing _save* and _rest* functions.  */
7043   if (htab->sfpr != NULL)
7044     {
7045       unsigned int i;
7046
7047       htab->sfpr->size = 0;
7048       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7049         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7050           return FALSE;
7051       if (htab->sfpr->size == 0)
7052         htab->sfpr->flags |= SEC_EXCLUDE;
7053     }
7054
7055   if (bfd_link_relocatable (info))
7056     return TRUE;
7057
7058   if (htab->elf.hgot != NULL)
7059     {
7060       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7061       /* Make .TOC. defined so as to prevent it being made dynamic.
7062          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7063       if (!htab->elf.hgot->def_regular
7064           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7065         {
7066           htab->elf.hgot->root.type = bfd_link_hash_defined;
7067           htab->elf.hgot->root.u.def.value = 0;
7068           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7069           htab->elf.hgot->def_regular = 1;
7070           htab->elf.hgot->root.linker_def = 1;
7071         }
7072       htab->elf.hgot->type = STT_OBJECT;
7073       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7074                                | STV_HIDDEN);
7075     }
7076
7077   if (htab->need_func_desc_adj)
7078     {
7079       elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7080       htab->need_func_desc_adj = 0;
7081     }
7082
7083   return TRUE;
7084 }
7085
7086 /* Return true if we have dynamic relocs against H that apply to
7087    read-only sections.  */
7088
7089 static bfd_boolean
7090 readonly_dynrelocs (struct elf_link_hash_entry *h)
7091 {
7092   struct ppc_link_hash_entry *eh;
7093   struct elf_dyn_relocs *p;
7094
7095   eh = (struct ppc_link_hash_entry *) h;
7096   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7097     {
7098       asection *s = p->sec->output_section;
7099
7100       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7101         return TRUE;
7102     }
7103   return FALSE;
7104 }
7105
7106 /* Return true if we have dynamic relocs against H or any of its weak
7107    aliases, that apply to read-only sections.  */
7108
7109 static bfd_boolean
7110 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7111 {
7112   struct ppc_link_hash_entry *eh;
7113
7114   eh = (struct ppc_link_hash_entry *) h;
7115   do
7116     {
7117       if (readonly_dynrelocs (&eh->elf))
7118         return TRUE;
7119       eh = eh->weakref;
7120     } while (eh != NULL && &eh->elf != h);
7121
7122   return FALSE;
7123 }
7124
7125 /* Return whether EH has pc-relative dynamic relocs.  */
7126
7127 static bfd_boolean
7128 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7129 {
7130   struct elf_dyn_relocs *p;
7131
7132   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7133     if (p->pc_count != 0)
7134       return TRUE;
7135   return FALSE;
7136 }
7137
7138 /* Return true if a global entry stub will be created for H.  Valid
7139    for ELFv2 before plt entries have been allocated.  */
7140
7141 static bfd_boolean
7142 global_entry_stub (struct elf_link_hash_entry *h)
7143 {
7144   struct plt_entry *pent;
7145
7146   if (!h->pointer_equality_needed
7147       || h->def_regular)
7148     return FALSE;
7149
7150   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7151     if (pent->plt.refcount > 0
7152         && pent->addend == 0)
7153       return TRUE;
7154
7155   return FALSE;
7156 }
7157
7158 /* Adjust a symbol defined by a dynamic object and referenced by a
7159    regular object.  The current definition is in some section of the
7160    dynamic object, but we're not including those sections.  We have to
7161    change the definition to something the rest of the link can
7162    understand.  */
7163
7164 static bfd_boolean
7165 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7166                                  struct elf_link_hash_entry *h)
7167 {
7168   struct ppc_link_hash_table *htab;
7169   asection *s, *srel;
7170
7171   htab = ppc_hash_table (info);
7172   if (htab == NULL)
7173     return FALSE;
7174
7175   /* Deal with function syms.  */
7176   if (h->type == STT_FUNC
7177       || h->type == STT_GNU_IFUNC
7178       || h->needs_plt)
7179     {
7180       /* Clear procedure linkage table information for any symbol that
7181          won't need a .plt entry.  */
7182       struct plt_entry *ent;
7183       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7184         if (ent->plt.refcount > 0)
7185           break;
7186       if (ent == NULL
7187           || (h->type != STT_GNU_IFUNC
7188               && (SYMBOL_CALLS_LOCAL (info, h)
7189                   || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
7190           || ((struct ppc_link_hash_entry *) h)->save_res)
7191         {
7192           h->plt.plist = NULL;
7193           h->needs_plt = 0;
7194           h->pointer_equality_needed = 0;
7195         }
7196       else if (abiversion (info->output_bfd) >= 2)
7197         {
7198           /* Taking a function's address in a read/write section
7199              doesn't require us to define the function symbol in the
7200              executable on a global entry stub.  A dynamic reloc can
7201              be used instead.  The reason we prefer a few more dynamic
7202              relocs is that calling via a global entry stub costs a
7203              few more instructions, and pointer_equality_needed causes
7204              extra work in ld.so when resolving these symbols.  */
7205           if (global_entry_stub (h)
7206               && !alias_readonly_dynrelocs (h))
7207             {
7208               h->pointer_equality_needed = 0;
7209               /* After adjust_dynamic_symbol, non_got_ref set in
7210                  the non-pic case means that dyn_relocs for this
7211                  symbol should be discarded.  */
7212               h->non_got_ref = 0;
7213             }
7214
7215           /* If making a plt entry, then we don't need copy relocs.  */
7216           return TRUE;
7217         }
7218     }
7219   else
7220     h->plt.plist = NULL;
7221
7222   /* If this is a weak symbol, and there is a real definition, the
7223      processor independent code will have arranged for us to see the
7224      real definition first, and we can just use the same value.  */
7225   if (h->u.weakdef != NULL)
7226     {
7227       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7228                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7229       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7230       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7231       if (ELIMINATE_COPY_RELOCS)
7232         h->non_got_ref = h->u.weakdef->non_got_ref;
7233       return TRUE;
7234     }
7235
7236   /* If we are creating a shared library, we must presume that the
7237      only references to the symbol are via the global offset table.
7238      For such cases we need not do anything here; the relocations will
7239      be handled correctly by relocate_section.  */
7240   if (bfd_link_pic (info))
7241     return TRUE;
7242
7243   /* If there are no references to this symbol that do not use the
7244      GOT, we don't need to generate a copy reloc.  */
7245   if (!h->non_got_ref)
7246     return TRUE;
7247
7248   /* Don't generate a copy reloc for symbols defined in the executable.  */
7249   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7250
7251       /* If -z nocopyreloc was given, don't generate them either.  */
7252       || info->nocopyreloc
7253
7254       /* If we didn't find any dynamic relocs in read-only sections, then
7255          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7256       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7257
7258       /* Protected variables do not work with .dynbss.  The copy in
7259          .dynbss won't be used by the shared library with the protected
7260          definition for the variable.  Text relocations are preferable
7261          to an incorrect program.  */
7262       || h->protected_def)
7263     {
7264       h->non_got_ref = 0;
7265       return TRUE;
7266     }
7267
7268   if (h->plt.plist != NULL)
7269     {
7270       /* We should never get here, but unfortunately there are versions
7271          of gcc out there that improperly (for this ABI) put initialized
7272          function pointers, vtable refs and suchlike in read-only
7273          sections.  Allow them to proceed, but warn that this might
7274          break at runtime.  */
7275       info->callbacks->einfo
7276         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7277            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7278          h->root.root.string);
7279     }
7280
7281   /* This is a reference to a symbol defined by a dynamic object which
7282      is not a function.  */
7283
7284   /* We must allocate the symbol in our .dynbss section, which will
7285      become part of the .bss section of the executable.  There will be
7286      an entry for this symbol in the .dynsym section.  The dynamic
7287      object will contain position independent code, so all references
7288      from the dynamic object to this symbol will go through the global
7289      offset table.  The dynamic linker will use the .dynsym entry to
7290      determine the address it must put in the global offset table, so
7291      both the dynamic object and the regular object will refer to the
7292      same memory location for the variable.  */
7293
7294   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7295      to copy the initial value out of the dynamic object and into the
7296      runtime process image.  We need to remember the offset into the
7297      .rela.bss section we are going to use.  */
7298   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7299     {
7300       s = htab->elf.sdynrelro;
7301       srel = htab->elf.sreldynrelro;
7302     }
7303   else
7304     {
7305       s = htab->elf.sdynbss;
7306       srel = htab->elf.srelbss;
7307     }
7308   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7309     {
7310       srel->size += sizeof (Elf64_External_Rela);
7311       h->needs_copy = 1;
7312     }
7313
7314   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7315 }
7316
7317 /* If given a function descriptor symbol, hide both the function code
7318    sym and the descriptor.  */
7319 static void
7320 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7321                        struct elf_link_hash_entry *h,
7322                        bfd_boolean force_local)
7323 {
7324   struct ppc_link_hash_entry *eh;
7325   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7326
7327   eh = (struct ppc_link_hash_entry *) h;
7328   if (eh->is_func_descriptor)
7329     {
7330       struct ppc_link_hash_entry *fh = eh->oh;
7331
7332       if (fh == NULL)
7333         {
7334           const char *p, *q;
7335           struct elf_link_hash_table *htab = elf_hash_table (info);
7336           char save;
7337
7338           /* We aren't supposed to use alloca in BFD because on
7339              systems which do not have alloca the version in libiberty
7340              calls xmalloc, which might cause the program to crash
7341              when it runs out of memory.  This function doesn't have a
7342              return status, so there's no way to gracefully return an
7343              error.  So cheat.  We know that string[-1] can be safely
7344              accessed;  It's either a string in an ELF string table,
7345              or allocated in an objalloc structure.  */
7346
7347           p = eh->elf.root.root.string - 1;
7348           save = *p;
7349           *(char *) p = '.';
7350           fh = (struct ppc_link_hash_entry *)
7351             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7352           *(char *) p = save;
7353
7354           /* Unfortunately, if it so happens that the string we were
7355              looking for was allocated immediately before this string,
7356              then we overwrote the string terminator.  That's the only
7357              reason the lookup should fail.  */
7358           if (fh == NULL)
7359             {
7360               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7361               while (q >= eh->elf.root.root.string && *q == *p)
7362                 --q, --p;
7363               if (q < eh->elf.root.root.string && *p == '.')
7364                 fh = (struct ppc_link_hash_entry *)
7365                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7366             }
7367           if (fh != NULL)
7368             {
7369               eh->oh = fh;
7370               fh->oh = eh;
7371             }
7372         }
7373       if (fh != NULL)
7374         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7375     }
7376 }
7377
7378 static bfd_boolean
7379 get_sym_h (struct elf_link_hash_entry **hp,
7380            Elf_Internal_Sym **symp,
7381            asection **symsecp,
7382            unsigned char **tls_maskp,
7383            Elf_Internal_Sym **locsymsp,
7384            unsigned long r_symndx,
7385            bfd *ibfd)
7386 {
7387   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7388
7389   if (r_symndx >= symtab_hdr->sh_info)
7390     {
7391       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7392       struct elf_link_hash_entry *h;
7393
7394       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7395       h = elf_follow_link (h);
7396
7397       if (hp != NULL)
7398         *hp = h;
7399
7400       if (symp != NULL)
7401         *symp = NULL;
7402
7403       if (symsecp != NULL)
7404         {
7405           asection *symsec = NULL;
7406           if (h->root.type == bfd_link_hash_defined
7407               || h->root.type == bfd_link_hash_defweak)
7408             symsec = h->root.u.def.section;
7409           *symsecp = symsec;
7410         }
7411
7412       if (tls_maskp != NULL)
7413         {
7414           struct ppc_link_hash_entry *eh;
7415
7416           eh = (struct ppc_link_hash_entry *) h;
7417           *tls_maskp = &eh->tls_mask;
7418         }
7419     }
7420   else
7421     {
7422       Elf_Internal_Sym *sym;
7423       Elf_Internal_Sym *locsyms = *locsymsp;
7424
7425       if (locsyms == NULL)
7426         {
7427           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7428           if (locsyms == NULL)
7429             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7430                                             symtab_hdr->sh_info,
7431                                             0, NULL, NULL, NULL);
7432           if (locsyms == NULL)
7433             return FALSE;
7434           *locsymsp = locsyms;
7435         }
7436       sym = locsyms + r_symndx;
7437
7438       if (hp != NULL)
7439         *hp = NULL;
7440
7441       if (symp != NULL)
7442         *symp = sym;
7443
7444       if (symsecp != NULL)
7445         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7446
7447       if (tls_maskp != NULL)
7448         {
7449           struct got_entry **lgot_ents;
7450           unsigned char *tls_mask;
7451
7452           tls_mask = NULL;
7453           lgot_ents = elf_local_got_ents (ibfd);
7454           if (lgot_ents != NULL)
7455             {
7456               struct plt_entry **local_plt = (struct plt_entry **)
7457                 (lgot_ents + symtab_hdr->sh_info);
7458               unsigned char *lgot_masks = (unsigned char *)
7459                 (local_plt + symtab_hdr->sh_info);
7460               tls_mask = &lgot_masks[r_symndx];
7461             }
7462           *tls_maskp = tls_mask;
7463         }
7464     }
7465   return TRUE;
7466 }
7467
7468 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7469    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7470    type suitable for optimization, and 1 otherwise.  */
7471
7472 static int
7473 get_tls_mask (unsigned char **tls_maskp,
7474               unsigned long *toc_symndx,
7475               bfd_vma *toc_addend,
7476               Elf_Internal_Sym **locsymsp,
7477               const Elf_Internal_Rela *rel,
7478               bfd *ibfd)
7479 {
7480   unsigned long r_symndx;
7481   int next_r;
7482   struct elf_link_hash_entry *h;
7483   Elf_Internal_Sym *sym;
7484   asection *sec;
7485   bfd_vma off;
7486
7487   r_symndx = ELF64_R_SYM (rel->r_info);
7488   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7489     return 0;
7490
7491   if ((*tls_maskp != NULL && **tls_maskp != 0)
7492       || sec == NULL
7493       || ppc64_elf_section_data (sec) == NULL
7494       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7495     return 1;
7496
7497   /* Look inside a TOC section too.  */
7498   if (h != NULL)
7499     {
7500       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7501       off = h->root.u.def.value;
7502     }
7503   else
7504     off = sym->st_value;
7505   off += rel->r_addend;
7506   BFD_ASSERT (off % 8 == 0);
7507   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7508   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7509   if (toc_symndx != NULL)
7510     *toc_symndx = r_symndx;
7511   if (toc_addend != NULL)
7512     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7513   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7514     return 0;
7515   if ((h == NULL || is_static_defined (h))
7516       && (next_r == -1 || next_r == -2))
7517     return 1 - next_r;
7518   return 1;
7519 }
7520
7521 /* Find (or create) an entry in the tocsave hash table.  */
7522
7523 static struct tocsave_entry *
7524 tocsave_find (struct ppc_link_hash_table *htab,
7525               enum insert_option insert,
7526               Elf_Internal_Sym **local_syms,
7527               const Elf_Internal_Rela *irela,
7528               bfd *ibfd)
7529 {
7530   unsigned long r_indx;
7531   struct elf_link_hash_entry *h;
7532   Elf_Internal_Sym *sym;
7533   struct tocsave_entry ent, *p;
7534   hashval_t hash;
7535   struct tocsave_entry **slot;
7536
7537   r_indx = ELF64_R_SYM (irela->r_info);
7538   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7539     return NULL;
7540   if (ent.sec == NULL || ent.sec->output_section == NULL)
7541     {
7542       _bfd_error_handler
7543         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7544       return NULL;
7545     }
7546
7547   if (h != NULL)
7548     ent.offset = h->root.u.def.value;
7549   else
7550     ent.offset = sym->st_value;
7551   ent.offset += irela->r_addend;
7552
7553   hash = tocsave_htab_hash (&ent);
7554   slot = ((struct tocsave_entry **)
7555           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7556   if (slot == NULL)
7557     return NULL;
7558
7559   if (*slot == NULL)
7560     {
7561       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7562       if (p == NULL)
7563         return NULL;
7564       *p = ent;
7565       *slot = p;
7566     }
7567   return *slot;
7568 }
7569
7570 /* Adjust all global syms defined in opd sections.  In gcc generated
7571    code for the old ABI, these will already have been done.  */
7572
7573 static bfd_boolean
7574 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7575 {
7576   struct ppc_link_hash_entry *eh;
7577   asection *sym_sec;
7578   struct _opd_sec_data *opd;
7579
7580   if (h->root.type == bfd_link_hash_indirect)
7581     return TRUE;
7582
7583   if (h->root.type != bfd_link_hash_defined
7584       && h->root.type != bfd_link_hash_defweak)
7585     return TRUE;
7586
7587   eh = (struct ppc_link_hash_entry *) h;
7588   if (eh->adjust_done)
7589     return TRUE;
7590
7591   sym_sec = eh->elf.root.u.def.section;
7592   opd = get_opd_info (sym_sec);
7593   if (opd != NULL && opd->adjust != NULL)
7594     {
7595       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7596       if (adjust == -1)
7597         {
7598           /* This entry has been deleted.  */
7599           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7600           if (dsec == NULL)
7601             {
7602               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7603                 if (discarded_section (dsec))
7604                   {
7605                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7606                     break;
7607                   }
7608             }
7609           eh->elf.root.u.def.value = 0;
7610           eh->elf.root.u.def.section = dsec;
7611         }
7612       else
7613         eh->elf.root.u.def.value += adjust;
7614       eh->adjust_done = 1;
7615     }
7616   return TRUE;
7617 }
7618
7619 /* Handles decrementing dynamic reloc counts for the reloc specified by
7620    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7621    have already been determined.  */
7622
7623 static bfd_boolean
7624 dec_dynrel_count (bfd_vma r_info,
7625                   asection *sec,
7626                   struct bfd_link_info *info,
7627                   Elf_Internal_Sym **local_syms,
7628                   struct elf_link_hash_entry *h,
7629                   Elf_Internal_Sym *sym)
7630 {
7631   enum elf_ppc64_reloc_type r_type;
7632   asection *sym_sec = NULL;
7633
7634   /* Can this reloc be dynamic?  This switch, and later tests here
7635      should be kept in sync with the code in check_relocs.  */
7636   r_type = ELF64_R_TYPE (r_info);
7637   switch (r_type)
7638     {
7639     default:
7640       return TRUE;
7641
7642     case R_PPC64_TPREL16:
7643     case R_PPC64_TPREL16_LO:
7644     case R_PPC64_TPREL16_HI:
7645     case R_PPC64_TPREL16_HA:
7646     case R_PPC64_TPREL16_DS:
7647     case R_PPC64_TPREL16_LO_DS:
7648     case R_PPC64_TPREL16_HIGH:
7649     case R_PPC64_TPREL16_HIGHA:
7650     case R_PPC64_TPREL16_HIGHER:
7651     case R_PPC64_TPREL16_HIGHERA:
7652     case R_PPC64_TPREL16_HIGHEST:
7653     case R_PPC64_TPREL16_HIGHESTA:
7654     case R_PPC64_TPREL64:
7655     case R_PPC64_DTPMOD64:
7656     case R_PPC64_DTPREL64:
7657     case R_PPC64_ADDR64:
7658     case R_PPC64_REL30:
7659     case R_PPC64_REL32:
7660     case R_PPC64_REL64:
7661     case R_PPC64_ADDR14:
7662     case R_PPC64_ADDR14_BRNTAKEN:
7663     case R_PPC64_ADDR14_BRTAKEN:
7664     case R_PPC64_ADDR16:
7665     case R_PPC64_ADDR16_DS:
7666     case R_PPC64_ADDR16_HA:
7667     case R_PPC64_ADDR16_HI:
7668     case R_PPC64_ADDR16_HIGH:
7669     case R_PPC64_ADDR16_HIGHA:
7670     case R_PPC64_ADDR16_HIGHER:
7671     case R_PPC64_ADDR16_HIGHERA:
7672     case R_PPC64_ADDR16_HIGHEST:
7673     case R_PPC64_ADDR16_HIGHESTA:
7674     case R_PPC64_ADDR16_LO:
7675     case R_PPC64_ADDR16_LO_DS:
7676     case R_PPC64_ADDR24:
7677     case R_PPC64_ADDR32:
7678     case R_PPC64_UADDR16:
7679     case R_PPC64_UADDR32:
7680     case R_PPC64_UADDR64:
7681     case R_PPC64_TOC:
7682       break;
7683     }
7684
7685   if (local_syms != NULL)
7686     {
7687       unsigned long r_symndx;
7688       bfd *ibfd = sec->owner;
7689
7690       r_symndx = ELF64_R_SYM (r_info);
7691       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7692         return FALSE;
7693     }
7694
7695   if ((bfd_link_pic (info)
7696        && (must_be_dyn_reloc (info, r_type)
7697            || (h != NULL
7698                && (!SYMBOLIC_BIND (info, h)
7699                    || h->root.type == bfd_link_hash_defweak
7700                    || !h->def_regular))))
7701       || (ELIMINATE_COPY_RELOCS
7702           && !bfd_link_pic (info)
7703           && h != NULL
7704           && (h->root.type == bfd_link_hash_defweak
7705               || !h->def_regular)))
7706     ;
7707   else
7708     return TRUE;
7709
7710   if (h != NULL)
7711     {
7712       struct elf_dyn_relocs *p;
7713       struct elf_dyn_relocs **pp;
7714       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7715
7716       /* elf_gc_sweep may have already removed all dyn relocs associated
7717          with local syms for a given section.  Also, symbol flags are
7718          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7719          report a dynreloc miscount.  */
7720       if (*pp == NULL && info->gc_sections)
7721         return TRUE;
7722
7723       while ((p = *pp) != NULL)
7724         {
7725           if (p->sec == sec)
7726             {
7727               if (!must_be_dyn_reloc (info, r_type))
7728                 p->pc_count -= 1;
7729               p->count -= 1;
7730               if (p->count == 0)
7731                 *pp = p->next;
7732               return TRUE;
7733             }
7734           pp = &p->next;
7735         }
7736     }
7737   else
7738     {
7739       struct ppc_dyn_relocs *p;
7740       struct ppc_dyn_relocs **pp;
7741       void *vpp;
7742       bfd_boolean is_ifunc;
7743
7744       if (local_syms == NULL)
7745         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7746       if (sym_sec == NULL)
7747         sym_sec = sec;
7748
7749       vpp = &elf_section_data (sym_sec)->local_dynrel;
7750       pp = (struct ppc_dyn_relocs **) vpp;
7751
7752       if (*pp == NULL && info->gc_sections)
7753         return TRUE;
7754
7755       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7756       while ((p = *pp) != NULL)
7757         {
7758           if (p->sec == sec && p->ifunc == is_ifunc)
7759             {
7760               p->count -= 1;
7761               if (p->count == 0)
7762                 *pp = p->next;
7763               return TRUE;
7764             }
7765           pp = &p->next;
7766         }
7767     }
7768
7769   /* xgettext:c-format */
7770   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7771                           sec->owner, sec);
7772   bfd_set_error (bfd_error_bad_value);
7773   return FALSE;
7774 }
7775
7776 /* Remove unused Official Procedure Descriptor entries.  Currently we
7777    only remove those associated with functions in discarded link-once
7778    sections, or weakly defined functions that have been overridden.  It
7779    would be possible to remove many more entries for statically linked
7780    applications.  */
7781
7782 bfd_boolean
7783 ppc64_elf_edit_opd (struct bfd_link_info *info)
7784 {
7785   bfd *ibfd;
7786   bfd_boolean some_edited = FALSE;
7787   asection *need_pad = NULL;
7788   struct ppc_link_hash_table *htab;
7789
7790   htab = ppc_hash_table (info);
7791   if (htab == NULL)
7792     return FALSE;
7793
7794   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7795     {
7796       asection *sec;
7797       Elf_Internal_Rela *relstart, *rel, *relend;
7798       Elf_Internal_Shdr *symtab_hdr;
7799       Elf_Internal_Sym *local_syms;
7800       struct _opd_sec_data *opd;
7801       bfd_boolean need_edit, add_aux_fields, broken;
7802       bfd_size_type cnt_16b = 0;
7803
7804       if (!is_ppc64_elf (ibfd))
7805         continue;
7806
7807       sec = bfd_get_section_by_name (ibfd, ".opd");
7808       if (sec == NULL || sec->size == 0)
7809         continue;
7810
7811       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7812         continue;
7813
7814       if (sec->output_section == bfd_abs_section_ptr)
7815         continue;
7816
7817       /* Look through the section relocs.  */
7818       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7819         continue;
7820
7821       local_syms = NULL;
7822       symtab_hdr = &elf_symtab_hdr (ibfd);
7823
7824       /* Read the relocations.  */
7825       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7826                                             info->keep_memory);
7827       if (relstart == NULL)
7828         return FALSE;
7829
7830       /* First run through the relocs to check they are sane, and to
7831          determine whether we need to edit this opd section.  */
7832       need_edit = FALSE;
7833       broken = FALSE;
7834       need_pad = sec;
7835       relend = relstart + sec->reloc_count;
7836       for (rel = relstart; rel < relend; )
7837         {
7838           enum elf_ppc64_reloc_type r_type;
7839           unsigned long r_symndx;
7840           asection *sym_sec;
7841           struct elf_link_hash_entry *h;
7842           Elf_Internal_Sym *sym;
7843           bfd_vma offset;
7844
7845           /* .opd contains an array of 16 or 24 byte entries.  We're
7846              only interested in the reloc pointing to a function entry
7847              point.  */
7848           offset = rel->r_offset;
7849           if (rel + 1 == relend
7850               || rel[1].r_offset != offset + 8)
7851             {
7852               /* If someone messes with .opd alignment then after a
7853                  "ld -r" we might have padding in the middle of .opd.
7854                  Also, there's nothing to prevent someone putting
7855                  something silly in .opd with the assembler.  No .opd
7856                  optimization for them!  */
7857             broken_opd:
7858               _bfd_error_handler
7859                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7860               broken = TRUE;
7861               break;
7862             }
7863
7864           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7865               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7866             {
7867               _bfd_error_handler
7868                 /* xgettext:c-format */
7869                 (_("%B: unexpected reloc type %u in .opd section"),
7870                  ibfd, r_type);
7871               broken = TRUE;
7872               break;
7873             }
7874
7875           r_symndx = ELF64_R_SYM (rel->r_info);
7876           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7877                           r_symndx, ibfd))
7878             goto error_ret;
7879
7880           if (sym_sec == NULL || sym_sec->owner == NULL)
7881             {
7882               const char *sym_name;
7883               if (h != NULL)
7884                 sym_name = h->root.root.string;
7885               else
7886                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7887                                              sym_sec);
7888
7889               _bfd_error_handler
7890                 /* xgettext:c-format */
7891                 (_("%B: undefined sym `%s' in .opd section"),
7892                  ibfd, sym_name);
7893               broken = TRUE;
7894               break;
7895             }
7896
7897           /* opd entries are always for functions defined in the
7898              current input bfd.  If the symbol isn't defined in the
7899              input bfd, then we won't be using the function in this
7900              bfd;  It must be defined in a linkonce section in another
7901              bfd, or is weak.  It's also possible that we are
7902              discarding the function due to a linker script /DISCARD/,
7903              which we test for via the output_section.  */
7904           if (sym_sec->owner != ibfd
7905               || sym_sec->output_section == bfd_abs_section_ptr)
7906             need_edit = TRUE;
7907
7908           rel += 2;
7909           if (rel + 1 == relend
7910               || (rel + 2 < relend
7911                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7912             ++rel;
7913
7914           if (rel == relend)
7915             {
7916               if (sec->size == offset + 24)
7917                 {
7918                   need_pad = NULL;
7919                   break;
7920                 }
7921               if (sec->size == offset + 16)
7922                 {
7923                   cnt_16b++;
7924                   break;
7925                 }
7926               goto broken_opd;
7927             }
7928           else if (rel + 1 < relend
7929                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7930                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7931             {
7932               if (rel[0].r_offset == offset + 16)
7933                 cnt_16b++;
7934               else if (rel[0].r_offset != offset + 24)
7935                 goto broken_opd;
7936             }
7937           else
7938             goto broken_opd;
7939         }
7940
7941       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7942
7943       if (!broken && (need_edit || add_aux_fields))
7944         {
7945           Elf_Internal_Rela *write_rel;
7946           Elf_Internal_Shdr *rel_hdr;
7947           bfd_byte *rptr, *wptr;
7948           bfd_byte *new_contents;
7949           bfd_size_type amt;
7950
7951           new_contents = NULL;
7952           amt = OPD_NDX (sec->size) * sizeof (long);
7953           opd = &ppc64_elf_section_data (sec)->u.opd;
7954           opd->adjust = bfd_zalloc (sec->owner, amt);
7955           if (opd->adjust == NULL)
7956             return FALSE;
7957
7958           /* This seems a waste of time as input .opd sections are all
7959              zeros as generated by gcc, but I suppose there's no reason
7960              this will always be so.  We might start putting something in
7961              the third word of .opd entries.  */
7962           if ((sec->flags & SEC_IN_MEMORY) == 0)
7963             {
7964               bfd_byte *loc;
7965               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7966                 {
7967                   if (loc != NULL)
7968                     free (loc);
7969                 error_ret:
7970                   if (local_syms != NULL
7971                       && symtab_hdr->contents != (unsigned char *) local_syms)
7972                     free (local_syms);
7973                   if (elf_section_data (sec)->relocs != relstart)
7974                     free (relstart);
7975                   return FALSE;
7976                 }
7977               sec->contents = loc;
7978               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7979             }
7980
7981           elf_section_data (sec)->relocs = relstart;
7982
7983           new_contents = sec->contents;
7984           if (add_aux_fields)
7985             {
7986               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7987               if (new_contents == NULL)
7988                 return FALSE;
7989               need_pad = NULL;
7990             }
7991           wptr = new_contents;
7992           rptr = sec->contents;
7993           write_rel = relstart;
7994           for (rel = relstart; rel < relend; )
7995             {
7996               unsigned long r_symndx;
7997               asection *sym_sec;
7998               struct elf_link_hash_entry *h;
7999               struct ppc_link_hash_entry *fdh = NULL;
8000               Elf_Internal_Sym *sym;
8001               long opd_ent_size;
8002               Elf_Internal_Rela *next_rel;
8003               bfd_boolean skip;
8004
8005               r_symndx = ELF64_R_SYM (rel->r_info);
8006               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8007                               r_symndx, ibfd))
8008                 goto error_ret;
8009
8010               next_rel = rel + 2;
8011               if (next_rel + 1 == relend
8012                   || (next_rel + 2 < relend
8013                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8014                 ++next_rel;
8015
8016               /* See if the .opd entry is full 24 byte or
8017                  16 byte (with fd_aux entry overlapped with next
8018                  fd_func).  */
8019               opd_ent_size = 24;
8020               if (next_rel == relend)
8021                 {
8022                   if (sec->size == rel->r_offset + 16)
8023                     opd_ent_size = 16;
8024                 }
8025               else if (next_rel->r_offset == rel->r_offset + 16)
8026                 opd_ent_size = 16;
8027
8028               if (h != NULL
8029                   && h->root.root.string[0] == '.')
8030                 {
8031                   fdh = ((struct ppc_link_hash_entry *) h)->oh;
8032                   if (fdh != NULL)
8033                     {
8034                       fdh = ppc_follow_link (fdh);
8035                       if (fdh->elf.root.type != bfd_link_hash_defined
8036                           && fdh->elf.root.type != bfd_link_hash_defweak)
8037                         fdh = NULL;
8038                     }
8039                 }
8040
8041               skip = (sym_sec->owner != ibfd
8042                       || sym_sec->output_section == bfd_abs_section_ptr);
8043               if (skip)
8044                 {
8045                   if (fdh != NULL && sym_sec->owner == ibfd)
8046                     {
8047                       /* Arrange for the function descriptor sym
8048                          to be dropped.  */
8049                       fdh->elf.root.u.def.value = 0;
8050                       fdh->elf.root.u.def.section = sym_sec;
8051                     }
8052                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8053
8054                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8055                     rel = next_rel;
8056                   else
8057                     while (1)
8058                       {
8059                         if (!dec_dynrel_count (rel->r_info, sec, info,
8060                                                NULL, h, sym))
8061                           goto error_ret;
8062
8063                         if (++rel == next_rel)
8064                           break;
8065
8066                         r_symndx = ELF64_R_SYM (rel->r_info);
8067                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8068                                         r_symndx, ibfd))
8069                           goto error_ret;
8070                       }
8071                 }
8072               else
8073                 {
8074                   /* We'll be keeping this opd entry.  */
8075                   long adjust;
8076
8077                   if (fdh != NULL)
8078                     {
8079                       /* Redefine the function descriptor symbol to
8080                          this location in the opd section.  It is
8081                          necessary to update the value here rather
8082                          than using an array of adjustments as we do
8083                          for local symbols, because various places
8084                          in the generic ELF code use the value
8085                          stored in u.def.value.  */
8086                       fdh->elf.root.u.def.value = wptr - new_contents;
8087                       fdh->adjust_done = 1;
8088                     }
8089
8090                   /* Local syms are a bit tricky.  We could
8091                      tweak them as they can be cached, but
8092                      we'd need to look through the local syms
8093                      for the function descriptor sym which we
8094                      don't have at the moment.  So keep an
8095                      array of adjustments.  */
8096                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8097                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8098
8099                   if (wptr != rptr)
8100                     memcpy (wptr, rptr, opd_ent_size);
8101                   wptr += opd_ent_size;
8102                   if (add_aux_fields && opd_ent_size == 16)
8103                     {
8104                       memset (wptr, '\0', 8);
8105                       wptr += 8;
8106                     }
8107
8108                   /* We need to adjust any reloc offsets to point to the
8109                      new opd entries.  */
8110                   for ( ; rel != next_rel; ++rel)
8111                     {
8112                       rel->r_offset += adjust;
8113                       if (write_rel != rel)
8114                         memcpy (write_rel, rel, sizeof (*rel));
8115                       ++write_rel;
8116                     }
8117                 }
8118
8119               rptr += opd_ent_size;
8120             }
8121
8122           sec->size = wptr - new_contents;
8123           sec->reloc_count = write_rel - relstart;
8124           if (add_aux_fields)
8125             {
8126               free (sec->contents);
8127               sec->contents = new_contents;
8128             }
8129
8130           /* Fudge the header size too, as this is used later in
8131              elf_bfd_final_link if we are emitting relocs.  */
8132           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8133           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8134           some_edited = TRUE;
8135         }
8136       else if (elf_section_data (sec)->relocs != relstart)
8137         free (relstart);
8138
8139       if (local_syms != NULL
8140           && symtab_hdr->contents != (unsigned char *) local_syms)
8141         {
8142           if (!info->keep_memory)
8143             free (local_syms);
8144           else
8145             symtab_hdr->contents = (unsigned char *) local_syms;
8146         }
8147     }
8148
8149   if (some_edited)
8150     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8151
8152   /* If we are doing a final link and the last .opd entry is just 16 byte
8153      long, add a 8 byte padding after it.  */
8154   if (need_pad != NULL && !bfd_link_relocatable (info))
8155     {
8156       bfd_byte *p;
8157
8158       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8159         {
8160           BFD_ASSERT (need_pad->size > 0);
8161
8162           p = bfd_malloc (need_pad->size + 8);
8163           if (p == NULL)
8164             return FALSE;
8165
8166           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8167                                           p, 0, need_pad->size))
8168             return FALSE;
8169
8170           need_pad->contents = p;
8171           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8172         }
8173       else
8174         {
8175           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8176           if (p == NULL)
8177             return FALSE;
8178
8179           need_pad->contents = p;
8180         }
8181
8182       memset (need_pad->contents + need_pad->size, 0, 8);
8183       need_pad->size += 8;
8184     }
8185
8186   return TRUE;
8187 }
8188
8189 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8190
8191 asection *
8192 ppc64_elf_tls_setup (struct bfd_link_info *info)
8193 {
8194   struct ppc_link_hash_table *htab;
8195
8196   htab = ppc_hash_table (info);
8197   if (htab == NULL)
8198     return NULL;
8199
8200   if (abiversion (info->output_bfd) == 1)
8201     htab->opd_abi = 1;
8202
8203   if (htab->params->no_multi_toc)
8204     htab->do_multi_toc = 0;
8205   else if (!htab->do_multi_toc)
8206     htab->params->no_multi_toc = 1;
8207
8208   /* Default to --no-plt-localentry, as this option can cause problems
8209      with symbol interposition.  For example, glibc libpthread.so and
8210      libc.so duplicate many pthread symbols, with a fallback
8211      implementation in libc.so.  In some cases the fallback does more
8212      work than the pthread implementation.  __pthread_condattr_destroy
8213      is one such symbol: the libpthread.so implementation is
8214      localentry:0 while the libc.so implementation is localentry:8.
8215      An app that "cleverly" uses dlopen to only load necessary
8216      libraries at runtime may omit loading libpthread.so when not
8217      running multi-threaded, which then results in the libc.so
8218      fallback symbols being used and ld.so complaining.  Now there
8219      are workarounds in ld (see non_zero_localentry) to detect the
8220      pthread situation, but that may not be the only case where
8221      --plt-localentry can cause trouble.  */
8222   if (htab->params->plt_localentry0 < 0)
8223     htab->params->plt_localentry0 = 0;
8224   if (htab->params->plt_localentry0
8225       && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8226                                FALSE, FALSE, FALSE) == NULL)
8227     info->callbacks->einfo
8228       (_("%P: warning: --plt-localentry is especially dangerous without "
8229          "ld.so support to detect ABI violations.\n"));
8230
8231   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8232                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8233                                               FALSE, FALSE, TRUE));
8234   /* Move dynamic linking info to the function descriptor sym.  */
8235   if (htab->tls_get_addr != NULL)
8236     func_desc_adjust (&htab->tls_get_addr->elf, info);
8237   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8238                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8239                                                  FALSE, FALSE, TRUE));
8240   if (htab->params->tls_get_addr_opt)
8241     {
8242       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8243
8244       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8245                                   FALSE, FALSE, TRUE);
8246       if (opt != NULL)
8247         func_desc_adjust (opt, info);
8248       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8249                                      FALSE, FALSE, TRUE);
8250       if (opt_fd != NULL
8251           && (opt_fd->root.type == bfd_link_hash_defined
8252               || opt_fd->root.type == bfd_link_hash_defweak))
8253         {
8254           /* If glibc supports an optimized __tls_get_addr call stub,
8255              signalled by the presence of __tls_get_addr_opt, and we'll
8256              be calling __tls_get_addr via a plt call stub, then
8257              make __tls_get_addr point to __tls_get_addr_opt.  */
8258           tga_fd = &htab->tls_get_addr_fd->elf;
8259           if (htab->elf.dynamic_sections_created
8260               && tga_fd != NULL
8261               && (tga_fd->type == STT_FUNC
8262                   || tga_fd->needs_plt)
8263               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8264                    || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8265             {
8266               struct plt_entry *ent;
8267
8268               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8269                 if (ent->plt.refcount > 0)
8270                   break;
8271               if (ent != NULL)
8272                 {
8273                   tga_fd->root.type = bfd_link_hash_indirect;
8274                   tga_fd->root.u.i.link = &opt_fd->root;
8275                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8276                   opt_fd->mark = 1;
8277                   if (opt_fd->dynindx != -1)
8278                     {
8279                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8280                       opt_fd->dynindx = -1;
8281                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8282                                               opt_fd->dynstr_index);
8283                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8284                         return NULL;
8285                     }
8286                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8287                   tga = &htab->tls_get_addr->elf;
8288                   if (opt != NULL && tga != NULL)
8289                     {
8290                       tga->root.type = bfd_link_hash_indirect;
8291                       tga->root.u.i.link = &opt->root;
8292                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8293                       opt->mark = 1;
8294                       _bfd_elf_link_hash_hide_symbol (info, opt,
8295                                                       tga->forced_local);
8296                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8297                     }
8298                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8299                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8300                   if (htab->tls_get_addr != NULL)
8301                     {
8302                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8303                       htab->tls_get_addr->is_func = 1;
8304                     }
8305                 }
8306             }
8307         }
8308       else if (htab->params->tls_get_addr_opt < 0)
8309         htab->params->tls_get_addr_opt = 0;
8310     }
8311   return _bfd_elf_tls_setup (info->output_bfd, info);
8312 }
8313
8314 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8315    HASH1 or HASH2.  */
8316
8317 static bfd_boolean
8318 branch_reloc_hash_match (const bfd *ibfd,
8319                          const Elf_Internal_Rela *rel,
8320                          const struct ppc_link_hash_entry *hash1,
8321                          const struct ppc_link_hash_entry *hash2)
8322 {
8323   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8324   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8325   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8326
8327   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8328     {
8329       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8330       struct elf_link_hash_entry *h;
8331
8332       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8333       h = elf_follow_link (h);
8334       if (h == &hash1->elf || h == &hash2->elf)
8335         return TRUE;
8336     }
8337   return FALSE;
8338 }
8339
8340 /* Run through all the TLS relocs looking for optimization
8341    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8342    a preliminary section layout so that we know the TLS segment
8343    offsets.  We can't optimize earlier because some optimizations need
8344    to know the tp offset, and we need to optimize before allocating
8345    dynamic relocations.  */
8346
8347 bfd_boolean
8348 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8349 {
8350   bfd *ibfd;
8351   asection *sec;
8352   struct ppc_link_hash_table *htab;
8353   unsigned char *toc_ref;
8354   int pass;
8355
8356   if (!bfd_link_executable (info))
8357     return TRUE;
8358
8359   htab = ppc_hash_table (info);
8360   if (htab == NULL)
8361     return FALSE;
8362
8363   /* Make two passes over the relocs.  On the first pass, mark toc
8364      entries involved with tls relocs, and check that tls relocs
8365      involved in setting up a tls_get_addr call are indeed followed by
8366      such a call.  If they are not, we can't do any tls optimization.
8367      On the second pass twiddle tls_mask flags to notify
8368      relocate_section that optimization can be done, and adjust got
8369      and plt refcounts.  */
8370   toc_ref = NULL;
8371   for (pass = 0; pass < 2; ++pass)
8372     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8373       {
8374         Elf_Internal_Sym *locsyms = NULL;
8375         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8376
8377         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8378           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8379             {
8380               Elf_Internal_Rela *relstart, *rel, *relend;
8381               bfd_boolean found_tls_get_addr_arg = 0;
8382
8383               /* Read the relocations.  */
8384               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8385                                                     info->keep_memory);
8386               if (relstart == NULL)
8387                 {
8388                   free (toc_ref);
8389                   return FALSE;
8390                 }
8391
8392               relend = relstart + sec->reloc_count;
8393               for (rel = relstart; rel < relend; rel++)
8394                 {
8395                   enum elf_ppc64_reloc_type r_type;
8396                   unsigned long r_symndx;
8397                   struct elf_link_hash_entry *h;
8398                   Elf_Internal_Sym *sym;
8399                   asection *sym_sec;
8400                   unsigned char *tls_mask;
8401                   unsigned char tls_set, tls_clear, tls_type = 0;
8402                   bfd_vma value;
8403                   bfd_boolean ok_tprel, is_local;
8404                   long toc_ref_index = 0;
8405                   int expecting_tls_get_addr = 0;
8406                   bfd_boolean ret = FALSE;
8407
8408                   r_symndx = ELF64_R_SYM (rel->r_info);
8409                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8410                                   r_symndx, ibfd))
8411                     {
8412                     err_free_rel:
8413                       if (elf_section_data (sec)->relocs != relstart)
8414                         free (relstart);
8415                       if (toc_ref != NULL)
8416                         free (toc_ref);
8417                       if (locsyms != NULL
8418                           && (elf_symtab_hdr (ibfd).contents
8419                               != (unsigned char *) locsyms))
8420                         free (locsyms);
8421                       return ret;
8422                     }
8423
8424                   if (h != NULL)
8425                     {
8426                       if (h->root.type == bfd_link_hash_defined
8427                           || h->root.type == bfd_link_hash_defweak)
8428                         value = h->root.u.def.value;
8429                       else if (h->root.type == bfd_link_hash_undefweak)
8430                         value = 0;
8431                       else
8432                         {
8433                           found_tls_get_addr_arg = 0;
8434                           continue;
8435                         }
8436                     }
8437                   else
8438                     /* Symbols referenced by TLS relocs must be of type
8439                        STT_TLS.  So no need for .opd local sym adjust.  */
8440                     value = sym->st_value;
8441
8442                   ok_tprel = FALSE;
8443                   is_local = FALSE;
8444                   if (h == NULL
8445                       || !h->def_dynamic)
8446                     {
8447                       is_local = TRUE;
8448                       if (h != NULL
8449                           && h->root.type == bfd_link_hash_undefweak)
8450                         ok_tprel = TRUE;
8451                       else if (sym_sec != NULL
8452                                && sym_sec->output_section != NULL)
8453                         {
8454                           value += sym_sec->output_offset;
8455                           value += sym_sec->output_section->vma;
8456                           value -= htab->elf.tls_sec->vma;
8457                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8458                                       < (bfd_vma) 1 << 32);
8459                         }
8460                     }
8461
8462                   r_type = ELF64_R_TYPE (rel->r_info);
8463                   /* If this section has old-style __tls_get_addr calls
8464                      without marker relocs, then check that each
8465                      __tls_get_addr call reloc is preceded by a reloc
8466                      that conceivably belongs to the __tls_get_addr arg
8467                      setup insn.  If we don't find matching arg setup
8468                      relocs, don't do any tls optimization.  */
8469                   if (pass == 0
8470                       && sec->has_tls_get_addr_call
8471                       && h != NULL
8472                       && (h == &htab->tls_get_addr->elf
8473                           || h == &htab->tls_get_addr_fd->elf)
8474                       && !found_tls_get_addr_arg
8475                       && is_branch_reloc (r_type))
8476                     {
8477                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8478                                                 "TLS optimization disabled\n"),
8479                                               ibfd, sec, rel->r_offset);
8480                       ret = TRUE;
8481                       goto err_free_rel;
8482                     }
8483
8484                   found_tls_get_addr_arg = 0;
8485                   switch (r_type)
8486                     {
8487                     case R_PPC64_GOT_TLSLD16:
8488                     case R_PPC64_GOT_TLSLD16_LO:
8489                       expecting_tls_get_addr = 1;
8490                       found_tls_get_addr_arg = 1;
8491                       /* Fall through.  */
8492
8493                     case R_PPC64_GOT_TLSLD16_HI:
8494                     case R_PPC64_GOT_TLSLD16_HA:
8495                       /* These relocs should never be against a symbol
8496                          defined in a shared lib.  Leave them alone if
8497                          that turns out to be the case.  */
8498                       if (!is_local)
8499                         continue;
8500
8501                       /* LD -> LE */
8502                       tls_set = 0;
8503                       tls_clear = TLS_LD;
8504                       tls_type = TLS_TLS | TLS_LD;
8505                       break;
8506
8507                     case R_PPC64_GOT_TLSGD16:
8508                     case R_PPC64_GOT_TLSGD16_LO:
8509                       expecting_tls_get_addr = 1;
8510                       found_tls_get_addr_arg = 1;
8511                       /* Fall through. */
8512
8513                     case R_PPC64_GOT_TLSGD16_HI:
8514                     case R_PPC64_GOT_TLSGD16_HA:
8515                       if (ok_tprel)
8516                         /* GD -> LE */
8517                         tls_set = 0;
8518                       else
8519                         /* GD -> IE */
8520                         tls_set = TLS_TLS | TLS_TPRELGD;
8521                       tls_clear = TLS_GD;
8522                       tls_type = TLS_TLS | TLS_GD;
8523                       break;
8524
8525                     case R_PPC64_GOT_TPREL16_DS:
8526                     case R_PPC64_GOT_TPREL16_LO_DS:
8527                     case R_PPC64_GOT_TPREL16_HI:
8528                     case R_PPC64_GOT_TPREL16_HA:
8529                       if (ok_tprel)
8530                         {
8531                           /* IE -> LE */
8532                           tls_set = 0;
8533                           tls_clear = TLS_TPREL;
8534                           tls_type = TLS_TLS | TLS_TPREL;
8535                           break;
8536                         }
8537                       continue;
8538
8539                     case R_PPC64_TLSGD:
8540                     case R_PPC64_TLSLD:
8541                       found_tls_get_addr_arg = 1;
8542                       /* Fall through.  */
8543
8544                     case R_PPC64_TLS:
8545                     case R_PPC64_TOC16:
8546                     case R_PPC64_TOC16_LO:
8547                       if (sym_sec == NULL || sym_sec != toc)
8548                         continue;
8549
8550                       /* Mark this toc entry as referenced by a TLS
8551                          code sequence.  We can do that now in the
8552                          case of R_PPC64_TLS, and after checking for
8553                          tls_get_addr for the TOC16 relocs.  */
8554                       if (toc_ref == NULL)
8555                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8556                       if (toc_ref == NULL)
8557                         goto err_free_rel;
8558
8559                       if (h != NULL)
8560                         value = h->root.u.def.value;
8561                       else
8562                         value = sym->st_value;
8563                       value += rel->r_addend;
8564                       if (value % 8 != 0)
8565                         continue;
8566                       BFD_ASSERT (value < toc->size
8567                                   && toc->output_offset % 8 == 0);
8568                       toc_ref_index = (value + toc->output_offset) / 8;
8569                       if (r_type == R_PPC64_TLS
8570                           || r_type == R_PPC64_TLSGD
8571                           || r_type == R_PPC64_TLSLD)
8572                         {
8573                           toc_ref[toc_ref_index] = 1;
8574                           continue;
8575                         }
8576
8577                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8578                         continue;
8579
8580                       tls_set = 0;
8581                       tls_clear = 0;
8582                       expecting_tls_get_addr = 2;
8583                       break;
8584
8585                     case R_PPC64_TPREL64:
8586                       if (pass == 0
8587                           || sec != toc
8588                           || toc_ref == NULL
8589                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8590                         continue;
8591                       if (ok_tprel)
8592                         {
8593                           /* IE -> LE */
8594                           tls_set = TLS_EXPLICIT;
8595                           tls_clear = TLS_TPREL;
8596                           break;
8597                         }
8598                       continue;
8599
8600                     case R_PPC64_DTPMOD64:
8601                       if (pass == 0
8602                           || sec != toc
8603                           || toc_ref == NULL
8604                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8605                         continue;
8606                       if (rel + 1 < relend
8607                           && (rel[1].r_info
8608                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8609                           && rel[1].r_offset == rel->r_offset + 8)
8610                         {
8611                           if (ok_tprel)
8612                             /* GD -> LE */
8613                             tls_set = TLS_EXPLICIT | TLS_GD;
8614                           else
8615                             /* GD -> IE */
8616                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8617                           tls_clear = TLS_GD;
8618                         }
8619                       else
8620                         {
8621                           if (!is_local)
8622                             continue;
8623
8624                           /* LD -> LE */
8625                           tls_set = TLS_EXPLICIT;
8626                           tls_clear = TLS_LD;
8627                         }
8628                       break;
8629
8630                     default:
8631                       continue;
8632                     }
8633
8634                   if (pass == 0)
8635                     {
8636                       if (!expecting_tls_get_addr
8637                           || !sec->has_tls_get_addr_call)
8638                         continue;
8639
8640                       if (rel + 1 < relend
8641                           && branch_reloc_hash_match (ibfd, rel + 1,
8642                                                       htab->tls_get_addr,
8643                                                       htab->tls_get_addr_fd))
8644                         {
8645                           if (expecting_tls_get_addr == 2)
8646                             {
8647                               /* Check for toc tls entries.  */
8648                               unsigned char *toc_tls;
8649                               int retval;
8650
8651                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8652                                                      &locsyms,
8653                                                      rel, ibfd);
8654                               if (retval == 0)
8655                                 goto err_free_rel;
8656                               if (toc_tls != NULL)
8657                                 {
8658                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8659                                     found_tls_get_addr_arg = 1;
8660                                   if (retval > 1)
8661                                     toc_ref[toc_ref_index] = 1;
8662                                 }
8663                             }
8664                           continue;
8665                         }
8666
8667                       if (expecting_tls_get_addr != 1)
8668                         continue;
8669
8670                       /* Uh oh, we didn't find the expected call.  We
8671                          could just mark this symbol to exclude it
8672                          from tls optimization but it's safer to skip
8673                          the entire optimization.  */
8674                       /* xgettext:c-format */
8675                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8676                                                 "TLS optimization disabled\n"),
8677                                               ibfd, sec, rel->r_offset);
8678                       ret = TRUE;
8679                       goto err_free_rel;
8680                     }
8681
8682                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8683                     {
8684                       struct plt_entry *ent;
8685                       for (ent = htab->tls_get_addr->elf.plt.plist;
8686                            ent != NULL;
8687                            ent = ent->next)
8688                         if (ent->addend == 0)
8689                           {
8690                             if (ent->plt.refcount > 0)
8691                               {
8692                                 ent->plt.refcount -= 1;
8693                                 expecting_tls_get_addr = 0;
8694                               }
8695                             break;
8696                           }
8697                     }
8698
8699                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8700                     {
8701                       struct plt_entry *ent;
8702                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8703                            ent != NULL;
8704                            ent = ent->next)
8705                         if (ent->addend == 0)
8706                           {
8707                             if (ent->plt.refcount > 0)
8708                               ent->plt.refcount -= 1;
8709                             break;
8710                           }
8711                     }
8712
8713                   if (tls_clear == 0)
8714                     continue;
8715
8716                   if ((tls_set & TLS_EXPLICIT) == 0)
8717                     {
8718                       struct got_entry *ent;
8719
8720                       /* Adjust got entry for this reloc.  */
8721                       if (h != NULL)
8722                         ent = h->got.glist;
8723                       else
8724                         ent = elf_local_got_ents (ibfd)[r_symndx];
8725
8726                       for (; ent != NULL; ent = ent->next)
8727                         if (ent->addend == rel->r_addend
8728                             && ent->owner == ibfd
8729                             && ent->tls_type == tls_type)
8730                           break;
8731                       if (ent == NULL)
8732                         abort ();
8733
8734                       if (tls_set == 0)
8735                         {
8736                           /* We managed to get rid of a got entry.  */
8737                           if (ent->got.refcount > 0)
8738                             ent->got.refcount -= 1;
8739                         }
8740                     }
8741                   else
8742                     {
8743                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8744                          we'll lose one or two dyn relocs.  */
8745                       if (!dec_dynrel_count (rel->r_info, sec, info,
8746                                              NULL, h, sym))
8747                         return FALSE;
8748
8749                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8750                         {
8751                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8752                                                  NULL, h, sym))
8753                             return FALSE;
8754                         }
8755                     }
8756
8757                   *tls_mask |= tls_set;
8758                   *tls_mask &= ~tls_clear;
8759                 }
8760
8761               if (elf_section_data (sec)->relocs != relstart)
8762                 free (relstart);
8763             }
8764
8765         if (locsyms != NULL
8766             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8767           {
8768             if (!info->keep_memory)
8769               free (locsyms);
8770             else
8771               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8772           }
8773       }
8774
8775   if (toc_ref != NULL)
8776     free (toc_ref);
8777   htab->do_tls_opt = 1;
8778   return TRUE;
8779 }
8780
8781 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8782    the values of any global symbols in a toc section that has been
8783    edited.  Globals in toc sections should be a rarity, so this function
8784    sets a flag if any are found in toc sections other than the one just
8785    edited, so that further hash table traversals can be avoided.  */
8786
8787 struct adjust_toc_info
8788 {
8789   asection *toc;
8790   unsigned long *skip;
8791   bfd_boolean global_toc_syms;
8792 };
8793
8794 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8795
8796 static bfd_boolean
8797 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8798 {
8799   struct ppc_link_hash_entry *eh;
8800   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8801   unsigned long i;
8802
8803   if (h->root.type != bfd_link_hash_defined
8804       && h->root.type != bfd_link_hash_defweak)
8805     return TRUE;
8806
8807   eh = (struct ppc_link_hash_entry *) h;
8808   if (eh->adjust_done)
8809     return TRUE;
8810
8811   if (eh->elf.root.u.def.section == toc_inf->toc)
8812     {
8813       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8814         i = toc_inf->toc->rawsize >> 3;
8815       else
8816         i = eh->elf.root.u.def.value >> 3;
8817
8818       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8819         {
8820           _bfd_error_handler
8821             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8822           do
8823             ++i;
8824           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8825           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8826         }
8827
8828       eh->elf.root.u.def.value -= toc_inf->skip[i];
8829       eh->adjust_done = 1;
8830     }
8831   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8832     toc_inf->global_toc_syms = TRUE;
8833
8834   return TRUE;
8835 }
8836
8837 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8838    on a _LO variety toc/got reloc.  */
8839
8840 static bfd_boolean
8841 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8842 {
8843   return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8844           || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8845           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8846           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8847           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8848           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8849           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8850           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8851           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8852           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8853           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8854           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8855           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8856           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8857           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8858           || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8859           || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8860               /* Exclude lfqu by testing reloc.  If relocs are ever
8861                  defined for the reduced D field in psq_lu then those
8862                  will need testing too.  */
8863               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8864           || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8865               && (insn & 1) == 0)
8866           || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8867           || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8868               /* Exclude stfqu.  psq_stu as above for psq_lu.  */
8869               && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8870           || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8871               && (insn & 1) == 0));
8872 }
8873
8874 /* Examine all relocs referencing .toc sections in order to remove
8875    unused .toc entries.  */
8876
8877 bfd_boolean
8878 ppc64_elf_edit_toc (struct bfd_link_info *info)
8879 {
8880   bfd *ibfd;
8881   struct adjust_toc_info toc_inf;
8882   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8883
8884   htab->do_toc_opt = 1;
8885   toc_inf.global_toc_syms = TRUE;
8886   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8887     {
8888       asection *toc, *sec;
8889       Elf_Internal_Shdr *symtab_hdr;
8890       Elf_Internal_Sym *local_syms;
8891       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8892       unsigned long *skip, *drop;
8893       unsigned char *used;
8894       unsigned char *keep, last, some_unused;
8895
8896       if (!is_ppc64_elf (ibfd))
8897         continue;
8898
8899       toc = bfd_get_section_by_name (ibfd, ".toc");
8900       if (toc == NULL
8901           || toc->size == 0
8902           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8903           || discarded_section (toc))
8904         continue;
8905
8906       toc_relocs = NULL;
8907       local_syms = NULL;
8908       symtab_hdr = &elf_symtab_hdr (ibfd);
8909
8910       /* Look at sections dropped from the final link.  */
8911       skip = NULL;
8912       relstart = NULL;
8913       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8914         {
8915           if (sec->reloc_count == 0
8916               || !discarded_section (sec)
8917               || get_opd_info (sec)
8918               || (sec->flags & SEC_ALLOC) == 0
8919               || (sec->flags & SEC_DEBUGGING) != 0)
8920             continue;
8921
8922           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8923           if (relstart == NULL)
8924             goto error_ret;
8925
8926           /* Run through the relocs to see which toc entries might be
8927              unused.  */
8928           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8929             {
8930               enum elf_ppc64_reloc_type r_type;
8931               unsigned long r_symndx;
8932               asection *sym_sec;
8933               struct elf_link_hash_entry *h;
8934               Elf_Internal_Sym *sym;
8935               bfd_vma val;
8936
8937               r_type = ELF64_R_TYPE (rel->r_info);
8938               switch (r_type)
8939                 {
8940                 default:
8941                   continue;
8942
8943                 case R_PPC64_TOC16:
8944                 case R_PPC64_TOC16_LO:
8945                 case R_PPC64_TOC16_HI:
8946                 case R_PPC64_TOC16_HA:
8947                 case R_PPC64_TOC16_DS:
8948                 case R_PPC64_TOC16_LO_DS:
8949                   break;
8950                 }
8951
8952               r_symndx = ELF64_R_SYM (rel->r_info);
8953               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8954                               r_symndx, ibfd))
8955                 goto error_ret;
8956
8957               if (sym_sec != toc)
8958                 continue;
8959
8960               if (h != NULL)
8961                 val = h->root.u.def.value;
8962               else
8963                 val = sym->st_value;
8964               val += rel->r_addend;
8965
8966               if (val >= toc->size)
8967                 continue;
8968
8969               /* Anything in the toc ought to be aligned to 8 bytes.
8970                  If not, don't mark as unused.  */
8971               if (val & 7)
8972                 continue;
8973
8974               if (skip == NULL)
8975                 {
8976                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8977                   if (skip == NULL)
8978                     goto error_ret;
8979                 }
8980
8981               skip[val >> 3] = ref_from_discarded;
8982             }
8983
8984           if (elf_section_data (sec)->relocs != relstart)
8985             free (relstart);
8986         }
8987
8988       /* For largetoc loads of address constants, we can convert
8989          .  addis rx,2,addr@got@ha
8990          .  ld ry,addr@got@l(rx)
8991          to
8992          .  addis rx,2,addr@toc@ha
8993          .  addi ry,rx,addr@toc@l
8994          when addr is within 2G of the toc pointer.  This then means
8995          that the word storing "addr" in the toc is no longer needed.  */
8996
8997       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8998           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8999           && toc->reloc_count != 0)
9000         {
9001           /* Read toc relocs.  */
9002           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9003                                                   info->keep_memory);
9004           if (toc_relocs == NULL)
9005             goto error_ret;
9006
9007           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9008             {
9009               enum elf_ppc64_reloc_type r_type;
9010               unsigned long r_symndx;
9011               asection *sym_sec;
9012               struct elf_link_hash_entry *h;
9013               Elf_Internal_Sym *sym;
9014               bfd_vma val, addr;
9015
9016               r_type = ELF64_R_TYPE (rel->r_info);
9017               if (r_type != R_PPC64_ADDR64)
9018                 continue;
9019
9020               r_symndx = ELF64_R_SYM (rel->r_info);
9021               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9022                               r_symndx, ibfd))
9023                 goto error_ret;
9024
9025               if (sym_sec == NULL
9026                   || sym_sec->output_section == NULL
9027                   || discarded_section (sym_sec))
9028                 continue;
9029
9030               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9031                 continue;
9032
9033               if (h != NULL)
9034                 {
9035                   if (h->type == STT_GNU_IFUNC)
9036                     continue;
9037                   val = h->root.u.def.value;
9038                 }
9039               else
9040                 {
9041                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9042                     continue;
9043                   val = sym->st_value;
9044                 }
9045               val += rel->r_addend;
9046               val += sym_sec->output_section->vma + sym_sec->output_offset;
9047
9048               /* We don't yet know the exact toc pointer value, but we
9049                  know it will be somewhere in the toc section.  Don't
9050                  optimize if the difference from any possible toc
9051                  pointer is outside [ff..f80008000, 7fff7fff].  */
9052               addr = toc->output_section->vma + TOC_BASE_OFF;
9053               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9054                 continue;
9055
9056               addr = toc->output_section->vma + toc->output_section->rawsize;
9057               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9058                 continue;
9059
9060               if (skip == NULL)
9061                 {
9062                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9063                   if (skip == NULL)
9064                     goto error_ret;
9065                 }
9066
9067               skip[rel->r_offset >> 3]
9068                 |= can_optimize | ((rel - toc_relocs) << 2);
9069             }
9070         }
9071
9072       if (skip == NULL)
9073         continue;
9074
9075       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9076       if (used == NULL)
9077         {
9078         error_ret:
9079           if (local_syms != NULL
9080               && symtab_hdr->contents != (unsigned char *) local_syms)
9081             free (local_syms);
9082           if (sec != NULL
9083               && relstart != NULL
9084               && elf_section_data (sec)->relocs != relstart)
9085             free (relstart);
9086           if (toc_relocs != NULL
9087               && elf_section_data (toc)->relocs != toc_relocs)
9088             free (toc_relocs);
9089           if (skip != NULL)
9090             free (skip);
9091           return FALSE;
9092         }
9093
9094       /* Now check all kept sections that might reference the toc.
9095          Check the toc itself last.  */
9096       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9097                   : ibfd->sections);
9098            sec != NULL;
9099            sec = (sec == toc ? NULL
9100                   : sec->next == NULL ? toc
9101                   : sec->next == toc && toc->next ? toc->next
9102                   : sec->next))
9103         {
9104           int repeat;
9105
9106           if (sec->reloc_count == 0
9107               || discarded_section (sec)
9108               || get_opd_info (sec)
9109               || (sec->flags & SEC_ALLOC) == 0
9110               || (sec->flags & SEC_DEBUGGING) != 0)
9111             continue;
9112
9113           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9114                                                 info->keep_memory);
9115           if (relstart == NULL)
9116             {
9117               free (used);
9118               goto error_ret;
9119             }
9120
9121           /* Mark toc entries referenced as used.  */
9122           do
9123             {
9124               repeat = 0;
9125               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9126                 {
9127                   enum elf_ppc64_reloc_type r_type;
9128                   unsigned long r_symndx;
9129                   asection *sym_sec;
9130                   struct elf_link_hash_entry *h;
9131                   Elf_Internal_Sym *sym;
9132                   bfd_vma val;
9133                   enum {no_check, check_lo, check_ha} insn_check;
9134
9135                   r_type = ELF64_R_TYPE (rel->r_info);
9136                   switch (r_type)
9137                     {
9138                     default:
9139                       insn_check = no_check;
9140                       break;
9141
9142                     case R_PPC64_GOT_TLSLD16_HA:
9143                     case R_PPC64_GOT_TLSGD16_HA:
9144                     case R_PPC64_GOT_TPREL16_HA:
9145                     case R_PPC64_GOT_DTPREL16_HA:
9146                     case R_PPC64_GOT16_HA:
9147                     case R_PPC64_TOC16_HA:
9148                       insn_check = check_ha;
9149                       break;
9150
9151                     case R_PPC64_GOT_TLSLD16_LO:
9152                     case R_PPC64_GOT_TLSGD16_LO:
9153                     case R_PPC64_GOT_TPREL16_LO_DS:
9154                     case R_PPC64_GOT_DTPREL16_LO_DS:
9155                     case R_PPC64_GOT16_LO:
9156                     case R_PPC64_GOT16_LO_DS:
9157                     case R_PPC64_TOC16_LO:
9158                     case R_PPC64_TOC16_LO_DS:
9159                       insn_check = check_lo;
9160                       break;
9161                     }
9162
9163                   if (insn_check != no_check)
9164                     {
9165                       bfd_vma off = rel->r_offset & ~3;
9166                       unsigned char buf[4];
9167                       unsigned int insn;
9168
9169                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9170                         {
9171                           free (used);
9172                           goto error_ret;
9173                         }
9174                       insn = bfd_get_32 (ibfd, buf);
9175                       if (insn_check == check_lo
9176                           ? !ok_lo_toc_insn (insn, r_type)
9177                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9178                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9179                         {
9180                           char str[12];
9181
9182                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9183                           sprintf (str, "%#08x", insn);
9184                           info->callbacks->einfo
9185                             /* xgettext:c-format */
9186                             (_("%H: toc optimization is not supported for"
9187                                " %s instruction.\n"),
9188                              ibfd, sec, rel->r_offset & ~3, str);
9189                         }
9190                     }
9191
9192                   switch (r_type)
9193                     {
9194                     case R_PPC64_TOC16:
9195                     case R_PPC64_TOC16_LO:
9196                     case R_PPC64_TOC16_HI:
9197                     case R_PPC64_TOC16_HA:
9198                     case R_PPC64_TOC16_DS:
9199                     case R_PPC64_TOC16_LO_DS:
9200                       /* In case we're taking addresses of toc entries.  */
9201                     case R_PPC64_ADDR64:
9202                       break;
9203
9204                     default:
9205                       continue;
9206                     }
9207
9208                   r_symndx = ELF64_R_SYM (rel->r_info);
9209                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9210                                   r_symndx, ibfd))
9211                     {
9212                       free (used);
9213                       goto error_ret;
9214                     }
9215
9216                   if (sym_sec != toc)
9217                     continue;
9218
9219                   if (h != NULL)
9220                     val = h->root.u.def.value;
9221                   else
9222                     val = sym->st_value;
9223                   val += rel->r_addend;
9224
9225                   if (val >= toc->size)
9226                     continue;
9227
9228                   if ((skip[val >> 3] & can_optimize) != 0)
9229                     {
9230                       bfd_vma off;
9231                       unsigned char opc;
9232
9233                       switch (r_type)
9234                         {
9235                         case R_PPC64_TOC16_HA:
9236                           break;
9237
9238                         case R_PPC64_TOC16_LO_DS:
9239                           off = rel->r_offset;
9240                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9241                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9242                                                          off, 1))
9243                             {
9244                               free (used);
9245                               goto error_ret;
9246                             }
9247                           if ((opc & (0x3f << 2)) == (58u << 2))
9248                             break;
9249                           /* Fall through.  */
9250
9251                         default:
9252                           /* Wrong sort of reloc, or not a ld.  We may
9253                              as well clear ref_from_discarded too.  */
9254                           skip[val >> 3] = 0;
9255                         }
9256                     }
9257
9258                   if (sec != toc)
9259                     used[val >> 3] = 1;
9260                   /* For the toc section, we only mark as used if this
9261                      entry itself isn't unused.  */
9262                   else if ((used[rel->r_offset >> 3]
9263                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9264                            && !used[val >> 3])
9265                     {
9266                       /* Do all the relocs again, to catch reference
9267                          chains.  */
9268                       repeat = 1;
9269                       used[val >> 3] = 1;
9270                     }
9271                 }
9272             }
9273           while (repeat);
9274
9275           if (elf_section_data (sec)->relocs != relstart)
9276             free (relstart);
9277         }
9278
9279       /* Merge the used and skip arrays.  Assume that TOC
9280          doublewords not appearing as either used or unused belong
9281          to an entry more than one doubleword in size.  */
9282       for (drop = skip, keep = used, last = 0, some_unused = 0;
9283            drop < skip + (toc->size + 7) / 8;
9284            ++drop, ++keep)
9285         {
9286           if (*keep)
9287             {
9288               *drop &= ~ref_from_discarded;
9289               if ((*drop & can_optimize) != 0)
9290                 some_unused = 1;
9291               last = 0;
9292             }
9293           else if ((*drop & ref_from_discarded) != 0)
9294             {
9295               some_unused = 1;
9296               last = ref_from_discarded;
9297             }
9298           else
9299             *drop = last;
9300         }
9301
9302       free (used);
9303
9304       if (some_unused)
9305         {
9306           bfd_byte *contents, *src;
9307           unsigned long off;
9308           Elf_Internal_Sym *sym;
9309           bfd_boolean local_toc_syms = FALSE;
9310
9311           /* Shuffle the toc contents, and at the same time convert the
9312              skip array from booleans into offsets.  */
9313           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9314             goto error_ret;
9315
9316           elf_section_data (toc)->this_hdr.contents = contents;
9317
9318           for (src = contents, off = 0, drop = skip;
9319                src < contents + toc->size;
9320                src += 8, ++drop)
9321             {
9322               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9323                 off += 8;
9324               else if (off != 0)
9325                 {
9326                   *drop = off;
9327                   memcpy (src - off, src, 8);
9328                 }
9329             }
9330           *drop = off;
9331           toc->rawsize = toc->size;
9332           toc->size = src - contents - off;
9333
9334           /* Adjust addends for relocs against the toc section sym,
9335              and optimize any accesses we can.  */
9336           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9337             {
9338               if (sec->reloc_count == 0
9339                   || discarded_section (sec))
9340                 continue;
9341
9342               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9343                                                     info->keep_memory);
9344               if (relstart == NULL)
9345                 goto error_ret;
9346
9347               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9348                 {
9349                   enum elf_ppc64_reloc_type r_type;
9350                   unsigned long r_symndx;
9351                   asection *sym_sec;
9352                   struct elf_link_hash_entry *h;
9353                   bfd_vma val;
9354
9355                   r_type = ELF64_R_TYPE (rel->r_info);
9356                   switch (r_type)
9357                     {
9358                     default:
9359                       continue;
9360
9361                     case R_PPC64_TOC16:
9362                     case R_PPC64_TOC16_LO:
9363                     case R_PPC64_TOC16_HI:
9364                     case R_PPC64_TOC16_HA:
9365                     case R_PPC64_TOC16_DS:
9366                     case R_PPC64_TOC16_LO_DS:
9367                     case R_PPC64_ADDR64:
9368                       break;
9369                     }
9370
9371                   r_symndx = ELF64_R_SYM (rel->r_info);
9372                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9373                                   r_symndx, ibfd))
9374                     goto error_ret;
9375
9376                   if (sym_sec != toc)
9377                     continue;
9378
9379                   if (h != NULL)
9380                     val = h->root.u.def.value;
9381                   else
9382                     {
9383                       val = sym->st_value;
9384                       if (val != 0)
9385                         local_toc_syms = TRUE;
9386                     }
9387
9388                   val += rel->r_addend;
9389
9390                   if (val > toc->rawsize)
9391                     val = toc->rawsize;
9392                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9393                     continue;
9394                   else if ((skip[val >> 3] & can_optimize) != 0)
9395                     {
9396                       Elf_Internal_Rela *tocrel
9397                         = toc_relocs + (skip[val >> 3] >> 2);
9398                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9399
9400                       switch (r_type)
9401                         {
9402                         case R_PPC64_TOC16_HA:
9403                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9404                           break;
9405
9406                         case R_PPC64_TOC16_LO_DS:
9407                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9408                           break;
9409
9410                         default:
9411                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9412                             ppc_howto_init ();
9413                           info->callbacks->einfo
9414                             /* xgettext:c-format */
9415                             (_("%H: %s references "
9416                                "optimized away TOC entry\n"),
9417                              ibfd, sec, rel->r_offset,
9418                              ppc64_elf_howto_table[r_type]->name);
9419                           bfd_set_error (bfd_error_bad_value);
9420                           goto error_ret;
9421                         }
9422                       rel->r_addend = tocrel->r_addend;
9423                       elf_section_data (sec)->relocs = relstart;
9424                       continue;
9425                     }
9426
9427                   if (h != NULL || sym->st_value != 0)
9428                     continue;
9429
9430                   rel->r_addend -= skip[val >> 3];
9431                   elf_section_data (sec)->relocs = relstart;
9432                 }
9433
9434               if (elf_section_data (sec)->relocs != relstart)
9435                 free (relstart);
9436             }
9437
9438           /* We shouldn't have local or global symbols defined in the TOC,
9439              but handle them anyway.  */
9440           if (local_syms != NULL)
9441             for (sym = local_syms;
9442                  sym < local_syms + symtab_hdr->sh_info;
9443                  ++sym)
9444               if (sym->st_value != 0
9445                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9446                 {
9447                   unsigned long i;
9448
9449                   if (sym->st_value > toc->rawsize)
9450                     i = toc->rawsize >> 3;
9451                   else
9452                     i = sym->st_value >> 3;
9453
9454                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9455                     {
9456                       if (local_toc_syms)
9457                         _bfd_error_handler
9458                           (_("%s defined on removed toc entry"),
9459                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9460                       do
9461                         ++i;
9462                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9463                       sym->st_value = (bfd_vma) i << 3;
9464                     }
9465
9466                   sym->st_value -= skip[i];
9467                   symtab_hdr->contents = (unsigned char *) local_syms;
9468                 }
9469
9470           /* Adjust any global syms defined in this toc input section.  */
9471           if (toc_inf.global_toc_syms)
9472             {
9473               toc_inf.toc = toc;
9474               toc_inf.skip = skip;
9475               toc_inf.global_toc_syms = FALSE;
9476               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9477                                       &toc_inf);
9478             }
9479
9480           if (toc->reloc_count != 0)
9481             {
9482               Elf_Internal_Shdr *rel_hdr;
9483               Elf_Internal_Rela *wrel;
9484               bfd_size_type sz;
9485
9486               /* Remove unused toc relocs, and adjust those we keep.  */
9487               if (toc_relocs == NULL)
9488                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9489                                                         info->keep_memory);
9490               if (toc_relocs == NULL)
9491                 goto error_ret;
9492
9493               wrel = toc_relocs;
9494               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9495                 if ((skip[rel->r_offset >> 3]
9496                      & (ref_from_discarded | can_optimize)) == 0)
9497                   {
9498                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9499                     wrel->r_info = rel->r_info;
9500                     wrel->r_addend = rel->r_addend;
9501                     ++wrel;
9502                   }
9503                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9504                                             &local_syms, NULL, NULL))
9505                   goto error_ret;
9506
9507               elf_section_data (toc)->relocs = toc_relocs;
9508               toc->reloc_count = wrel - toc_relocs;
9509               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9510               sz = rel_hdr->sh_entsize;
9511               rel_hdr->sh_size = toc->reloc_count * sz;
9512             }
9513         }
9514       else if (toc_relocs != NULL
9515                && elf_section_data (toc)->relocs != toc_relocs)
9516         free (toc_relocs);
9517
9518       if (local_syms != NULL
9519           && symtab_hdr->contents != (unsigned char *) local_syms)
9520         {
9521           if (!info->keep_memory)
9522             free (local_syms);
9523           else
9524             symtab_hdr->contents = (unsigned char *) local_syms;
9525         }
9526       free (skip);
9527     }
9528
9529   return TRUE;
9530 }
9531
9532 /* Return true iff input section I references the TOC using
9533    instructions limited to +/-32k offsets.  */
9534
9535 bfd_boolean
9536 ppc64_elf_has_small_toc_reloc (asection *i)
9537 {
9538   return (is_ppc64_elf (i->owner)
9539           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9540 }
9541
9542 /* Allocate space for one GOT entry.  */
9543
9544 static void
9545 allocate_got (struct elf_link_hash_entry *h,
9546               struct bfd_link_info *info,
9547               struct got_entry *gent)
9548 {
9549   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9550   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9551   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9552                  ? 16 : 8);
9553   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9554                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9555   asection *got = ppc64_elf_tdata (gent->owner)->got;
9556
9557   gent->got.offset = got->size;
9558   got->size += entsize;
9559
9560   if (h->type == STT_GNU_IFUNC)
9561     {
9562       htab->elf.irelplt->size += rentsize;
9563       htab->got_reli_size += rentsize;
9564     }
9565   else if ((bfd_link_pic (info)
9566             || (htab->elf.dynamic_sections_created
9567                 && h->dynindx != -1
9568                 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9569            && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9570     {
9571       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9572       relgot->size += rentsize;
9573     }
9574 }
9575
9576 /* This function merges got entries in the same toc group.  */
9577
9578 static void
9579 merge_got_entries (struct got_entry **pent)
9580 {
9581   struct got_entry *ent, *ent2;
9582
9583   for (ent = *pent; ent != NULL; ent = ent->next)
9584     if (!ent->is_indirect)
9585       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9586         if (!ent2->is_indirect
9587             && ent2->addend == ent->addend
9588             && ent2->tls_type == ent->tls_type
9589             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9590           {
9591             ent2->is_indirect = TRUE;
9592             ent2->got.ent = ent;
9593           }
9594 }
9595
9596 /* If H is undefined, make it dynamic if that makes sense.  */
9597
9598 static bfd_boolean
9599 ensure_undef_dynamic (struct bfd_link_info *info,
9600                       struct elf_link_hash_entry *h)
9601 {
9602   struct elf_link_hash_table *htab = elf_hash_table (info);
9603
9604   if (htab->dynamic_sections_created
9605       && ((info->dynamic_undefined_weak != 0
9606            && h->root.type == bfd_link_hash_undefweak)
9607           || h->root.type == bfd_link_hash_undefined)
9608       && h->dynindx == -1
9609       && !h->forced_local
9610       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9611     return bfd_elf_link_record_dynamic_symbol (info, h);
9612   return TRUE;
9613 }
9614
9615 /* Allocate space in .plt, .got and associated reloc sections for
9616    dynamic relocs.  */
9617
9618 static bfd_boolean
9619 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9620 {
9621   struct bfd_link_info *info;
9622   struct ppc_link_hash_table *htab;
9623   asection *s;
9624   struct ppc_link_hash_entry *eh;
9625   struct got_entry **pgent, *gent;
9626
9627   if (h->root.type == bfd_link_hash_indirect)
9628     return TRUE;
9629
9630   info = (struct bfd_link_info *) inf;
9631   htab = ppc_hash_table (info);
9632   if (htab == NULL)
9633     return FALSE;
9634
9635   eh = (struct ppc_link_hash_entry *) h;
9636   /* Run through the TLS GD got entries first if we're changing them
9637      to TPREL.  */
9638   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9639     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9640       if (gent->got.refcount > 0
9641           && (gent->tls_type & TLS_GD) != 0)
9642         {
9643           /* This was a GD entry that has been converted to TPREL.  If
9644              there happens to be a TPREL entry we can use that one.  */
9645           struct got_entry *ent;
9646           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9647             if (ent->got.refcount > 0
9648                 && (ent->tls_type & TLS_TPREL) != 0
9649                 && ent->addend == gent->addend
9650                 && ent->owner == gent->owner)
9651               {
9652                 gent->got.refcount = 0;
9653                 break;
9654               }
9655
9656           /* If not, then we'll be using our own TPREL entry.  */
9657           if (gent->got.refcount != 0)
9658             gent->tls_type = TLS_TLS | TLS_TPREL;
9659         }
9660
9661   /* Remove any list entry that won't generate a word in the GOT before
9662      we call merge_got_entries.  Otherwise we risk merging to empty
9663      entries.  */
9664   pgent = &h->got.glist;
9665   while ((gent = *pgent) != NULL)
9666     if (gent->got.refcount > 0)
9667       {
9668         if ((gent->tls_type & TLS_LD) != 0
9669             && !h->def_dynamic)
9670           {
9671             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9672             *pgent = gent->next;
9673           }
9674         else
9675           pgent = &gent->next;
9676       }
9677     else
9678       *pgent = gent->next;
9679
9680   if (!htab->do_multi_toc)
9681     merge_got_entries (&h->got.glist);
9682
9683   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9684     if (!gent->is_indirect)
9685       {
9686         /* Make sure this symbol is output as a dynamic symbol.  */
9687         if (!ensure_undef_dynamic (info, h))
9688           return FALSE;
9689
9690         if (!is_ppc64_elf (gent->owner))
9691           abort ();
9692
9693         allocate_got (h, info, gent);
9694       }
9695
9696   /* If no dynamic sections we can't have dynamic relocs, except for
9697      IFUNCs which are handled even in static executables.  */
9698   if (!htab->elf.dynamic_sections_created
9699       && h->type != STT_GNU_IFUNC)
9700     eh->dyn_relocs = NULL;
9701
9702   /* Also discard relocs on undefined weak syms with non-default
9703      visibility, or when dynamic_undefined_weak says so.  */
9704   else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9705     eh->dyn_relocs = NULL;
9706
9707   if (eh->dyn_relocs != NULL)
9708     {
9709       struct elf_dyn_relocs *p, **pp;
9710
9711       /* In the shared -Bsymbolic case, discard space allocated for
9712          dynamic pc-relative relocs against symbols which turn out to
9713          be defined in regular objects.  For the normal shared case,
9714          discard space for relocs that have become local due to symbol
9715          visibility changes.  */
9716
9717       if (bfd_link_pic (info))
9718         {
9719           /* Relocs that use pc_count are those that appear on a call
9720              insn, or certain REL relocs (see must_be_dyn_reloc) that
9721              can be generated via assembly.  We want calls to
9722              protected symbols to resolve directly to the function
9723              rather than going via the plt.  If people want function
9724              pointer comparisons to work as expected then they should
9725              avoid writing weird assembly.  */
9726           if (SYMBOL_CALLS_LOCAL (info, h))
9727             {
9728               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9729                 {
9730                   p->count -= p->pc_count;
9731                   p->pc_count = 0;
9732                   if (p->count == 0)
9733                     *pp = p->next;
9734                   else
9735                     pp = &p->next;
9736                 }
9737             }
9738
9739           if (eh->dyn_relocs != NULL)
9740             {
9741               /* Make sure this symbol is output as a dynamic symbol.  */
9742               if (!ensure_undef_dynamic (info, h))
9743                 return FALSE;
9744             }
9745         }
9746       else if (h->type == STT_GNU_IFUNC)
9747         {
9748           /* A plt entry is always created when making direct calls to
9749              an ifunc, even when building a static executable, but
9750              that doesn't cover all cases.  We may have only an ifunc
9751              initialised function pointer for a given ifunc symbol.
9752
9753              For ELFv2, dynamic relocations are not required when
9754              generating a global entry PLT stub.  */
9755           if (abiversion (info->output_bfd) >= 2)
9756             {
9757               if (global_entry_stub (h))
9758                 eh->dyn_relocs = NULL;
9759             }
9760
9761           /* For ELFv1 we have function descriptors.  Descriptors need
9762              to be treated like PLT entries and thus have dynamic
9763              relocations.  One exception is when the function
9764              descriptor is copied into .dynbss (which should only
9765              happen with ancient versions of gcc).  */
9766           else if (h->needs_copy)
9767             eh->dyn_relocs = NULL;
9768         }
9769       else if (ELIMINATE_COPY_RELOCS)
9770         {
9771           /* For the non-pic case, discard space for relocs against
9772              symbols which turn out to need copy relocs or are not
9773              dynamic.  */
9774           if (!h->non_got_ref
9775               && !h->def_regular)
9776             {
9777               /* Make sure this symbol is output as a dynamic symbol.  */
9778               if (!ensure_undef_dynamic (info, h))
9779                 return FALSE;
9780
9781               if (h->dynindx == -1)
9782                 eh->dyn_relocs = NULL;
9783             }
9784           else
9785             eh->dyn_relocs = NULL;
9786         }
9787
9788       /* Finally, allocate space.  */
9789       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9790         {
9791           asection *sreloc = elf_section_data (p->sec)->sreloc;
9792           if (eh->elf.type == STT_GNU_IFUNC)
9793             sreloc = htab->elf.irelplt;
9794           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9795         }
9796     }
9797
9798   if ((htab->elf.dynamic_sections_created
9799        && h->dynindx != -1)
9800       || h->type == STT_GNU_IFUNC)
9801     {
9802       struct plt_entry *pent;
9803       bfd_boolean doneone = FALSE;
9804       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9805         if (pent->plt.refcount > 0)
9806           {
9807             if (!htab->elf.dynamic_sections_created
9808                 || h->dynindx == -1)
9809               {
9810                 s = htab->elf.iplt;
9811                 pent->plt.offset = s->size;
9812                 s->size += PLT_ENTRY_SIZE (htab);
9813                 s = htab->elf.irelplt;
9814               }
9815             else
9816               {
9817                 /* If this is the first .plt entry, make room for the special
9818                    first entry.  */
9819                 s = htab->elf.splt;
9820                 if (s->size == 0)
9821                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9822
9823                 pent->plt.offset = s->size;
9824
9825                 /* Make room for this entry.  */
9826                 s->size += PLT_ENTRY_SIZE (htab);
9827
9828                 /* Make room for the .glink code.  */
9829                 s = htab->glink;
9830                 if (s->size == 0)
9831                   s->size += GLINK_CALL_STUB_SIZE;
9832                 if (htab->opd_abi)
9833                   {
9834                     /* We need bigger stubs past index 32767.  */
9835                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9836                       s->size += 4;
9837                     s->size += 2*4;
9838                   }
9839                 else
9840                   s->size += 4;
9841
9842                 /* We also need to make an entry in the .rela.plt section.  */
9843                 s = htab->elf.srelplt;
9844               }
9845             s->size += sizeof (Elf64_External_Rela);
9846             doneone = TRUE;
9847           }
9848         else
9849           pent->plt.offset = (bfd_vma) -1;
9850       if (!doneone)
9851         {
9852           h->plt.plist = NULL;
9853           h->needs_plt = 0;
9854         }
9855     }
9856   else
9857     {
9858       h->plt.plist = NULL;
9859       h->needs_plt = 0;
9860     }
9861
9862   return TRUE;
9863 }
9864
9865 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9866    to set up space for global entry stubs.  These are put in glink,
9867    after the branch table.  */
9868
9869 static bfd_boolean
9870 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9871 {
9872   struct bfd_link_info *info;
9873   struct ppc_link_hash_table *htab;
9874   struct plt_entry *pent;
9875   asection *s;
9876
9877   if (h->root.type == bfd_link_hash_indirect)
9878     return TRUE;
9879
9880   if (!h->pointer_equality_needed)
9881     return TRUE;
9882
9883   if (h->def_regular)
9884     return TRUE;
9885
9886   info = inf;
9887   htab = ppc_hash_table (info);
9888   if (htab == NULL)
9889     return FALSE;
9890
9891   s = htab->glink;
9892   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9893     if (pent->plt.offset != (bfd_vma) -1
9894         && pent->addend == 0)
9895       {
9896         /* For ELFv2, if this symbol is not defined in a regular file
9897            and we are not generating a shared library or pie, then we
9898            need to define the symbol in the executable on a call stub.
9899            This is to avoid text relocations.  */
9900         s->size = (s->size + 15) & -16;
9901         h->root.type = bfd_link_hash_defined;
9902         h->root.u.def.section = s;
9903         h->root.u.def.value = s->size;
9904         s->size += 16;
9905         break;
9906       }
9907   return TRUE;
9908 }
9909
9910 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9911    read-only sections.  */
9912
9913 static bfd_boolean
9914 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9915 {
9916   if (h->root.type == bfd_link_hash_indirect)
9917     return TRUE;
9918
9919   if (readonly_dynrelocs (h))
9920     {
9921       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9922
9923       /* Not an error, just cut short the traversal.  */
9924       return FALSE;
9925     }
9926   return TRUE;
9927 }
9928
9929 /* Set the sizes of the dynamic sections.  */
9930
9931 static bfd_boolean
9932 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9933                                  struct bfd_link_info *info)
9934 {
9935   struct ppc_link_hash_table *htab;
9936   bfd *dynobj;
9937   asection *s;
9938   bfd_boolean relocs;
9939   bfd *ibfd;
9940   struct got_entry *first_tlsld;
9941
9942   htab = ppc_hash_table (info);
9943   if (htab == NULL)
9944     return FALSE;
9945
9946   dynobj = htab->elf.dynobj;
9947   if (dynobj == NULL)
9948     abort ();
9949
9950   if (htab->elf.dynamic_sections_created)
9951     {
9952       /* Set the contents of the .interp section to the interpreter.  */
9953       if (bfd_link_executable (info) && !info->nointerp)
9954         {
9955           s = bfd_get_linker_section (dynobj, ".interp");
9956           if (s == NULL)
9957             abort ();
9958           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9959           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9960         }
9961     }
9962
9963   /* Set up .got offsets for local syms, and space for local dynamic
9964      relocs.  */
9965   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9966     {
9967       struct got_entry **lgot_ents;
9968       struct got_entry **end_lgot_ents;
9969       struct plt_entry **local_plt;
9970       struct plt_entry **end_local_plt;
9971       unsigned char *lgot_masks;
9972       bfd_size_type locsymcount;
9973       Elf_Internal_Shdr *symtab_hdr;
9974
9975       if (!is_ppc64_elf (ibfd))
9976         continue;
9977
9978       for (s = ibfd->sections; s != NULL; s = s->next)
9979         {
9980           struct ppc_dyn_relocs *p;
9981
9982           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9983             {
9984               if (!bfd_is_abs_section (p->sec)
9985                   && bfd_is_abs_section (p->sec->output_section))
9986                 {
9987                   /* Input section has been discarded, either because
9988                      it is a copy of a linkonce section or due to
9989                      linker script /DISCARD/, so we'll be discarding
9990                      the relocs too.  */
9991                 }
9992               else if (p->count != 0)
9993                 {
9994                   asection *srel = elf_section_data (p->sec)->sreloc;
9995                   if (p->ifunc)
9996                     srel = htab->elf.irelplt;
9997                   srel->size += p->count * sizeof (Elf64_External_Rela);
9998                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9999                     info->flags |= DF_TEXTREL;
10000                 }
10001             }
10002         }
10003
10004       lgot_ents = elf_local_got_ents (ibfd);
10005       if (!lgot_ents)
10006         continue;
10007
10008       symtab_hdr = &elf_symtab_hdr (ibfd);
10009       locsymcount = symtab_hdr->sh_info;
10010       end_lgot_ents = lgot_ents + locsymcount;
10011       local_plt = (struct plt_entry **) end_lgot_ents;
10012       end_local_plt = local_plt + locsymcount;
10013       lgot_masks = (unsigned char *) end_local_plt;
10014       s = ppc64_elf_tdata (ibfd)->got;
10015       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10016         {
10017           struct got_entry **pent, *ent;
10018
10019           pent = lgot_ents;
10020           while ((ent = *pent) != NULL)
10021             if (ent->got.refcount > 0)
10022               {
10023                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10024                   {
10025                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10026                     *pent = ent->next;
10027                   }
10028                 else
10029                   {
10030                     unsigned int ent_size = 8;
10031                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10032
10033                     ent->got.offset = s->size;
10034                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10035                       {
10036                         ent_size *= 2;
10037                         rel_size *= 2;
10038                       }
10039                     s->size += ent_size;
10040                     if ((*lgot_masks & PLT_IFUNC) != 0)
10041                       {
10042                         htab->elf.irelplt->size += rel_size;
10043                         htab->got_reli_size += rel_size;
10044                       }
10045                     else if (bfd_link_pic (info))
10046                       {
10047                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10048                         srel->size += rel_size;
10049                       }
10050                     pent = &ent->next;
10051                   }
10052               }
10053             else
10054               *pent = ent->next;
10055         }
10056
10057       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10058       for (; local_plt < end_local_plt; ++local_plt)
10059         {
10060           struct plt_entry *ent;
10061
10062           for (ent = *local_plt; ent != NULL; ent = ent->next)
10063             if (ent->plt.refcount > 0)
10064               {
10065                 s = htab->elf.iplt;
10066                 ent->plt.offset = s->size;
10067                 s->size += PLT_ENTRY_SIZE (htab);
10068
10069                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10070               }
10071             else
10072               ent->plt.offset = (bfd_vma) -1;
10073         }
10074     }
10075
10076   /* Allocate global sym .plt and .got entries, and space for global
10077      sym dynamic relocs.  */
10078   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10079   /* Stash the end of glink branch table.  */
10080   if (htab->glink != NULL)
10081     htab->glink->rawsize = htab->glink->size;
10082
10083   if (!htab->opd_abi && !bfd_link_pic (info))
10084     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10085
10086   first_tlsld = NULL;
10087   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10088     {
10089       struct got_entry *ent;
10090
10091       if (!is_ppc64_elf (ibfd))
10092         continue;
10093
10094       ent = ppc64_tlsld_got (ibfd);
10095       if (ent->got.refcount > 0)
10096         {
10097           if (!htab->do_multi_toc && first_tlsld != NULL)
10098             {
10099               ent->is_indirect = TRUE;
10100               ent->got.ent = first_tlsld;
10101             }
10102           else
10103             {
10104               if (first_tlsld == NULL)
10105                 first_tlsld = ent;
10106               s = ppc64_elf_tdata (ibfd)->got;
10107               ent->got.offset = s->size;
10108               ent->owner = ibfd;
10109               s->size += 16;
10110               if (bfd_link_pic (info))
10111                 {
10112                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10113                   srel->size += sizeof (Elf64_External_Rela);
10114                 }
10115             }
10116         }
10117       else
10118         ent->got.offset = (bfd_vma) -1;
10119     }
10120
10121   /* We now have determined the sizes of the various dynamic sections.
10122      Allocate memory for them.  */
10123   relocs = FALSE;
10124   for (s = dynobj->sections; s != NULL; s = s->next)
10125     {
10126       if ((s->flags & SEC_LINKER_CREATED) == 0)
10127         continue;
10128
10129       if (s == htab->brlt || s == htab->relbrlt)
10130         /* These haven't been allocated yet;  don't strip.  */
10131         continue;
10132       else if (s == htab->elf.sgot
10133                || s == htab->elf.splt
10134                || s == htab->elf.iplt
10135                || s == htab->glink
10136                || s == htab->elf.sdynbss
10137                || s == htab->elf.sdynrelro)
10138         {
10139           /* Strip this section if we don't need it; see the
10140              comment below.  */
10141         }
10142       else if (s == htab->glink_eh_frame)
10143         {
10144           if (!bfd_is_abs_section (s->output_section))
10145             /* Not sized yet.  */
10146             continue;
10147         }
10148       else if (CONST_STRNEQ (s->name, ".rela"))
10149         {
10150           if (s->size != 0)
10151             {
10152               if (s != htab->elf.srelplt)
10153                 relocs = TRUE;
10154
10155               /* We use the reloc_count field as a counter if we need
10156                  to copy relocs into the output file.  */
10157               s->reloc_count = 0;
10158             }
10159         }
10160       else
10161         {
10162           /* It's not one of our sections, so don't allocate space.  */
10163           continue;
10164         }
10165
10166       if (s->size == 0)
10167         {
10168           /* If we don't need this section, strip it from the
10169              output file.  This is mostly to handle .rela.bss and
10170              .rela.plt.  We must create both sections in
10171              create_dynamic_sections, because they must be created
10172              before the linker maps input sections to output
10173              sections.  The linker does that before
10174              adjust_dynamic_symbol is called, and it is that
10175              function which decides whether anything needs to go
10176              into these sections.  */
10177           s->flags |= SEC_EXCLUDE;
10178           continue;
10179         }
10180
10181       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10182         continue;
10183
10184       /* Allocate memory for the section contents.  We use bfd_zalloc
10185          here in case unused entries are not reclaimed before the
10186          section's contents are written out.  This should not happen,
10187          but this way if it does we get a R_PPC64_NONE reloc in .rela
10188          sections instead of garbage.
10189          We also rely on the section contents being zero when writing
10190          the GOT and .dynrelro.  */
10191       s->contents = bfd_zalloc (dynobj, s->size);
10192       if (s->contents == NULL)
10193         return FALSE;
10194     }
10195
10196   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10197     {
10198       if (!is_ppc64_elf (ibfd))
10199         continue;
10200
10201       s = ppc64_elf_tdata (ibfd)->got;
10202       if (s != NULL && s != htab->elf.sgot)
10203         {
10204           if (s->size == 0)
10205             s->flags |= SEC_EXCLUDE;
10206           else
10207             {
10208               s->contents = bfd_zalloc (ibfd, s->size);
10209               if (s->contents == NULL)
10210                 return FALSE;
10211             }
10212         }
10213       s = ppc64_elf_tdata (ibfd)->relgot;
10214       if (s != NULL)
10215         {
10216           if (s->size == 0)
10217             s->flags |= SEC_EXCLUDE;
10218           else
10219             {
10220               s->contents = bfd_zalloc (ibfd, s->size);
10221               if (s->contents == NULL)
10222                 return FALSE;
10223               relocs = TRUE;
10224               s->reloc_count = 0;
10225             }
10226         }
10227     }
10228
10229   if (htab->elf.dynamic_sections_created)
10230     {
10231       bfd_boolean tls_opt;
10232
10233       /* Add some entries to the .dynamic section.  We fill in the
10234          values later, in ppc64_elf_finish_dynamic_sections, but we
10235          must add the entries now so that we get the correct size for
10236          the .dynamic section.  The DT_DEBUG entry is filled in by the
10237          dynamic linker and used by the debugger.  */
10238 #define add_dynamic_entry(TAG, VAL) \
10239   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10240
10241       if (bfd_link_executable (info))
10242         {
10243           if (!add_dynamic_entry (DT_DEBUG, 0))
10244             return FALSE;
10245         }
10246
10247       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10248         {
10249           if (!add_dynamic_entry (DT_PLTGOT, 0)
10250               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10251               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10252               || !add_dynamic_entry (DT_JMPREL, 0)
10253               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10254             return FALSE;
10255         }
10256
10257       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10258         {
10259           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10260               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10261             return FALSE;
10262         }
10263
10264       tls_opt = (htab->params->tls_get_addr_opt
10265                  && htab->tls_get_addr_fd != NULL
10266                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10267       if (tls_opt || !htab->opd_abi)
10268         {
10269           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10270             return FALSE;
10271         }
10272
10273       if (relocs)
10274         {
10275           if (!add_dynamic_entry (DT_RELA, 0)
10276               || !add_dynamic_entry (DT_RELASZ, 0)
10277               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10278             return FALSE;
10279
10280           /* If any dynamic relocs apply to a read-only section,
10281              then we need a DT_TEXTREL entry.  */
10282           if ((info->flags & DF_TEXTREL) == 0)
10283             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10284
10285           if ((info->flags & DF_TEXTREL) != 0)
10286             {
10287               if (!add_dynamic_entry (DT_TEXTREL, 0))
10288                 return FALSE;
10289             }
10290         }
10291     }
10292 #undef add_dynamic_entry
10293
10294   return TRUE;
10295 }
10296
10297 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10298
10299 static bfd_boolean
10300 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10301 {
10302   if (h->plt.plist != NULL
10303       && !h->def_regular
10304       && !h->pointer_equality_needed)
10305     return FALSE;
10306
10307   return _bfd_elf_hash_symbol (h);
10308 }
10309
10310 /* Determine the type of stub needed, if any, for a call.  */
10311
10312 static inline enum ppc_stub_type
10313 ppc_type_of_stub (asection *input_sec,
10314                   const Elf_Internal_Rela *rel,
10315                   struct ppc_link_hash_entry **hash,
10316                   struct plt_entry **plt_ent,
10317                   bfd_vma destination,
10318                   unsigned long local_off)
10319 {
10320   struct ppc_link_hash_entry *h = *hash;
10321   bfd_vma location;
10322   bfd_vma branch_offset;
10323   bfd_vma max_branch_offset;
10324   enum elf_ppc64_reloc_type r_type;
10325
10326   if (h != NULL)
10327     {
10328       struct plt_entry *ent;
10329       struct ppc_link_hash_entry *fdh = h;
10330       if (h->oh != NULL
10331           && h->oh->is_func_descriptor)
10332         {
10333           fdh = ppc_follow_link (h->oh);
10334           *hash = fdh;
10335         }
10336
10337       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10338         if (ent->addend == rel->r_addend
10339             && ent->plt.offset != (bfd_vma) -1)
10340           {
10341             *plt_ent = ent;
10342             return ppc_stub_plt_call;
10343           }
10344
10345       /* Here, we know we don't have a plt entry.  If we don't have a
10346          either a defined function descriptor or a defined entry symbol
10347          in a regular object file, then it is pointless trying to make
10348          any other type of stub.  */
10349       if (!is_static_defined (&fdh->elf)
10350           && !is_static_defined (&h->elf))
10351         return ppc_stub_none;
10352     }
10353   else if (elf_local_got_ents (input_sec->owner) != NULL)
10354     {
10355       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10356       struct plt_entry **local_plt = (struct plt_entry **)
10357         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10358       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10359
10360       if (local_plt[r_symndx] != NULL)
10361         {
10362           struct plt_entry *ent;
10363
10364           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10365             if (ent->addend == rel->r_addend
10366                 && ent->plt.offset != (bfd_vma) -1)
10367               {
10368                 *plt_ent = ent;
10369                 return ppc_stub_plt_call;
10370               }
10371         }
10372     }
10373
10374   /* Determine where the call point is.  */
10375   location = (input_sec->output_offset
10376               + input_sec->output_section->vma
10377               + rel->r_offset);
10378
10379   branch_offset = destination - location;
10380   r_type = ELF64_R_TYPE (rel->r_info);
10381
10382   /* Determine if a long branch stub is needed.  */
10383   max_branch_offset = 1 << 25;
10384   if (r_type != R_PPC64_REL24)
10385     max_branch_offset = 1 << 15;
10386
10387   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10388     /* We need a stub.  Figure out whether a long_branch or plt_branch
10389        is needed later.  */
10390     return ppc_stub_long_branch;
10391
10392   return ppc_stub_none;
10393 }
10394
10395 /* With power7 weakly ordered memory model, it is possible for ld.so
10396    to update a plt entry in one thread and have another thread see a
10397    stale zero toc entry.  To avoid this we need some sort of acquire
10398    barrier in the call stub.  One solution is to make the load of the
10399    toc word seem to appear to depend on the load of the function entry
10400    word.  Another solution is to test for r2 being zero, and branch to
10401    the appropriate glink entry if so.
10402
10403    .    fake dep barrier        compare
10404    .    ld 12,xxx(2)            ld 12,xxx(2)
10405    .    mtctr 12                mtctr 12
10406    .    xor 11,12,12            ld 2,xxx+8(2)
10407    .    add 2,2,11              cmpldi 2,0
10408    .    ld 2,xxx+8(2)           bnectr+
10409    .    bctr                    b <glink_entry>
10410
10411    The solution involving the compare turns out to be faster, so
10412    that's what we use unless the branch won't reach.  */
10413
10414 #define ALWAYS_USE_FAKE_DEP 0
10415 #define ALWAYS_EMIT_R2SAVE 0
10416
10417 #define PPC_LO(v) ((v) & 0xffff)
10418 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10419 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10420
10421 static inline unsigned int
10422 plt_stub_size (struct ppc_link_hash_table *htab,
10423                struct ppc_stub_hash_entry *stub_entry,
10424                bfd_vma off)
10425 {
10426   unsigned size = 12;
10427
10428   if (ALWAYS_EMIT_R2SAVE
10429       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10430     size += 4;
10431   if (PPC_HA (off) != 0)
10432     size += 4;
10433   if (htab->opd_abi)
10434     {
10435       size += 4;
10436       if (htab->params->plt_static_chain)
10437         size += 4;
10438       if (htab->params->plt_thread_safe
10439           && htab->elf.dynamic_sections_created
10440           && stub_entry->h != NULL
10441           && stub_entry->h->elf.dynindx != -1)
10442         size += 8;
10443       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10444         size += 4;
10445     }
10446   if (stub_entry->h != NULL
10447       && (stub_entry->h == htab->tls_get_addr_fd
10448           || stub_entry->h == htab->tls_get_addr)
10449       && htab->params->tls_get_addr_opt)
10450     {
10451       size += 7 * 4;
10452       if (ALWAYS_EMIT_R2SAVE
10453           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10454         size += 6 * 4;
10455     }
10456   return size;
10457 }
10458
10459 /* Depending on the sign of plt_stub_align:
10460    If positive, return the padding to align to a 2**plt_stub_align
10461    boundary.
10462    If negative, if this stub would cross fewer 2**plt_stub_align
10463    boundaries if we align, then return the padding needed to do so.  */
10464
10465 static inline unsigned int
10466 plt_stub_pad (struct ppc_link_hash_table *htab,
10467               struct ppc_stub_hash_entry *stub_entry,
10468               bfd_vma plt_off)
10469 {
10470   int stub_align;
10471   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10472   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10473
10474   if (htab->params->plt_stub_align >= 0)
10475     {
10476       stub_align = 1 << htab->params->plt_stub_align;
10477       if ((stub_off & (stub_align - 1)) != 0)
10478         return stub_align - (stub_off & (stub_align - 1));
10479       return 0;
10480     }
10481
10482   stub_align = 1 << -htab->params->plt_stub_align;
10483   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10484       > ((stub_size - 1) & -stub_align))
10485     return stub_align - (stub_off & (stub_align - 1));
10486   return 0;
10487 }
10488
10489 /* Build a .plt call stub.  */
10490
10491 static inline bfd_byte *
10492 build_plt_stub (struct ppc_link_hash_table *htab,
10493                 struct ppc_stub_hash_entry *stub_entry,
10494                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10495 {
10496   bfd *obfd = htab->params->stub_bfd;
10497   bfd_boolean plt_load_toc = htab->opd_abi;
10498   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10499   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10500                                  && htab->elf.dynamic_sections_created
10501                                  && stub_entry->h != NULL
10502                                  && stub_entry->h->elf.dynindx != -1);
10503   bfd_boolean use_fake_dep = plt_thread_safe;
10504   bfd_vma cmp_branch_off = 0;
10505
10506   if (!ALWAYS_USE_FAKE_DEP
10507       && plt_load_toc
10508       && plt_thread_safe
10509       && !((stub_entry->h == htab->tls_get_addr_fd
10510             || stub_entry->h == htab->tls_get_addr)
10511            && htab->params->tls_get_addr_opt))
10512     {
10513       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10514       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10515                           / PLT_ENTRY_SIZE (htab));
10516       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10517       bfd_vma to, from;
10518
10519       if (pltindex > 32768)
10520         glinkoff += (pltindex - 32768) * 4;
10521       to = (glinkoff
10522             + htab->glink->output_offset
10523             + htab->glink->output_section->vma);
10524       from = (p - stub_entry->group->stub_sec->contents
10525               + 4 * (ALWAYS_EMIT_R2SAVE
10526                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10527               + 4 * (PPC_HA (offset) != 0)
10528               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10529                      != PPC_HA (offset))
10530               + 4 * (plt_static_chain != 0)
10531               + 20
10532               + stub_entry->group->stub_sec->output_offset
10533               + stub_entry->group->stub_sec->output_section->vma);
10534       cmp_branch_off = to - from;
10535       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10536     }
10537
10538   if (PPC_HA (offset) != 0)
10539     {
10540       if (r != NULL)
10541         {
10542           if (ALWAYS_EMIT_R2SAVE
10543               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10544             r[0].r_offset += 4;
10545           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10546           r[1].r_offset = r[0].r_offset + 4;
10547           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10548           r[1].r_addend = r[0].r_addend;
10549           if (plt_load_toc)
10550             {
10551               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10552                 {
10553                   r[2].r_offset = r[1].r_offset + 4;
10554                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10555                   r[2].r_addend = r[0].r_addend;
10556                 }
10557               else
10558                 {
10559                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10560                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10561                   r[2].r_addend = r[0].r_addend + 8;
10562                   if (plt_static_chain)
10563                     {
10564                       r[3].r_offset = r[2].r_offset + 4;
10565                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10566                       r[3].r_addend = r[0].r_addend + 16;
10567                     }
10568                 }
10569             }
10570         }
10571       if (ALWAYS_EMIT_R2SAVE
10572           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10573         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10574       if (plt_load_toc)
10575         {
10576           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10577           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10578         }
10579       else
10580         {
10581           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10582           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10583         }
10584       if (plt_load_toc
10585           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10586         {
10587           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10588           offset = 0;
10589         }
10590       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10591       if (plt_load_toc)
10592         {
10593           if (use_fake_dep)
10594             {
10595               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10596               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10597             }
10598           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10599           if (plt_static_chain)
10600             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10601         }
10602     }
10603   else
10604     {
10605       if (r != NULL)
10606         {
10607           if (ALWAYS_EMIT_R2SAVE
10608               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10609             r[0].r_offset += 4;
10610           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10611           if (plt_load_toc)
10612             {
10613               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10614                 {
10615                   r[1].r_offset = r[0].r_offset + 4;
10616                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10617                   r[1].r_addend = r[0].r_addend;
10618                 }
10619               else
10620                 {
10621                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10622                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10623                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10624                   if (plt_static_chain)
10625                     {
10626                       r[2].r_offset = r[1].r_offset + 4;
10627                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10628                       r[2].r_addend = r[0].r_addend + 8;
10629                     }
10630                 }
10631             }
10632         }
10633       if (ALWAYS_EMIT_R2SAVE
10634           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10635         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10636       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10637       if (plt_load_toc
10638           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10639         {
10640           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10641           offset = 0;
10642         }
10643       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10644       if (plt_load_toc)
10645         {
10646           if (use_fake_dep)
10647             {
10648               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10649               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10650             }
10651           if (plt_static_chain)
10652             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10653           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10654         }
10655     }
10656   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10657     {
10658       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10659       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10660       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10661     }
10662   else
10663     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10664   return p;
10665 }
10666
10667 /* Build a special .plt call stub for __tls_get_addr.  */
10668
10669 #define LD_R11_0R3      0xe9630000
10670 #define LD_R12_0R3      0xe9830000
10671 #define MR_R0_R3        0x7c601b78
10672 #define CMPDI_R11_0     0x2c2b0000
10673 #define ADD_R3_R12_R13  0x7c6c6a14
10674 #define BEQLR           0x4d820020
10675 #define MR_R3_R0        0x7c030378
10676 #define STD_R11_0R1     0xf9610000
10677 #define BCTRL           0x4e800421
10678 #define LD_R11_0R1      0xe9610000
10679 #define MTLR_R11        0x7d6803a6
10680
10681 static inline bfd_byte *
10682 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10683                          struct ppc_stub_hash_entry *stub_entry,
10684                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10685 {
10686   bfd *obfd = htab->params->stub_bfd;
10687
10688   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10689   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10690   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10691   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10692   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10693   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10694   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10695   if (r != NULL)
10696     r[0].r_offset += 7 * 4;
10697   if (!ALWAYS_EMIT_R2SAVE
10698       && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10699     return build_plt_stub (htab, stub_entry, p, offset, r);
10700
10701   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10702   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10703
10704   if (r != NULL)
10705     r[0].r_offset += 2 * 4;
10706   p = build_plt_stub (htab, stub_entry, p, offset, r);
10707   bfd_put_32 (obfd, BCTRL, p - 4);
10708
10709   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10710   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10711   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10712   bfd_put_32 (obfd, BLR, p),                    p += 4;
10713
10714   return p;
10715 }
10716
10717 static Elf_Internal_Rela *
10718 get_relocs (asection *sec, int count)
10719 {
10720   Elf_Internal_Rela *relocs;
10721   struct bfd_elf_section_data *elfsec_data;
10722
10723   elfsec_data = elf_section_data (sec);
10724   relocs = elfsec_data->relocs;
10725   if (relocs == NULL)
10726     {
10727       bfd_size_type relsize;
10728       relsize = sec->reloc_count * sizeof (*relocs);
10729       relocs = bfd_alloc (sec->owner, relsize);
10730       if (relocs == NULL)
10731         return NULL;
10732       elfsec_data->relocs = relocs;
10733       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10734                                           sizeof (Elf_Internal_Shdr));
10735       if (elfsec_data->rela.hdr == NULL)
10736         return NULL;
10737       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10738                                         * sizeof (Elf64_External_Rela));
10739       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10740       sec->reloc_count = 0;
10741     }
10742   relocs += sec->reloc_count;
10743   sec->reloc_count += count;
10744   return relocs;
10745 }
10746
10747 static bfd_vma
10748 get_r2off (struct bfd_link_info *info,
10749            struct ppc_stub_hash_entry *stub_entry)
10750 {
10751   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10752   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10753
10754   if (r2off == 0)
10755     {
10756       /* Support linking -R objects.  Get the toc pointer from the
10757          opd entry.  */
10758       char buf[8];
10759       if (!htab->opd_abi)
10760         return r2off;
10761       asection *opd = stub_entry->h->elf.root.u.def.section;
10762       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10763
10764       if (strcmp (opd->name, ".opd") != 0
10765           || opd->reloc_count != 0)
10766         {
10767           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10768                                   stub_entry->h->elf.root.root.string);
10769           bfd_set_error (bfd_error_bad_value);
10770           return (bfd_vma) -1;
10771         }
10772       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10773         return (bfd_vma) -1;
10774       r2off = bfd_get_64 (opd->owner, buf);
10775       r2off -= elf_gp (info->output_bfd);
10776     }
10777   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10778   return r2off;
10779 }
10780
10781 static bfd_boolean
10782 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10783 {
10784   struct ppc_stub_hash_entry *stub_entry;
10785   struct ppc_branch_hash_entry *br_entry;
10786   struct bfd_link_info *info;
10787   struct ppc_link_hash_table *htab;
10788   bfd_byte *loc;
10789   bfd_byte *p;
10790   bfd_vma dest, off;
10791   int size;
10792   Elf_Internal_Rela *r;
10793   asection *plt;
10794
10795   /* Massage our args to the form they really have.  */
10796   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10797   info = in_arg;
10798
10799   htab = ppc_hash_table (info);
10800   if (htab == NULL)
10801     return FALSE;
10802
10803   /* Make a note of the offset within the stubs for this entry.  */
10804   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10805   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10806
10807   htab->stub_count[stub_entry->stub_type - 1] += 1;
10808   switch (stub_entry->stub_type)
10809     {
10810     case ppc_stub_long_branch:
10811     case ppc_stub_long_branch_r2off:
10812       /* Branches are relative.  This is where we are going to.  */
10813       dest = (stub_entry->target_value
10814               + stub_entry->target_section->output_offset
10815               + stub_entry->target_section->output_section->vma);
10816       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10817       off = dest;
10818
10819       /* And this is where we are coming from.  */
10820       off -= (stub_entry->stub_offset
10821               + stub_entry->group->stub_sec->output_offset
10822               + stub_entry->group->stub_sec->output_section->vma);
10823
10824       size = 4;
10825       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10826         {
10827           bfd_vma r2off = get_r2off (info, stub_entry);
10828
10829           if (r2off == (bfd_vma) -1)
10830             {
10831               htab->stub_error = TRUE;
10832               return FALSE;
10833             }
10834           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10835           loc += 4;
10836           size = 8;
10837           if (PPC_HA (r2off) != 0)
10838             {
10839               bfd_put_32 (htab->params->stub_bfd,
10840                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10841               loc += 4;
10842               size += 4;
10843             }
10844           if (PPC_LO (r2off) != 0)
10845             {
10846               bfd_put_32 (htab->params->stub_bfd,
10847                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10848               loc += 4;
10849               size += 4;
10850             }
10851           off -= size - 4;
10852         }
10853       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10854
10855       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10856         {
10857           info->callbacks->einfo
10858             (_("%P: long branch stub `%s' offset overflow\n"),
10859              stub_entry->root.string);
10860           htab->stub_error = TRUE;
10861           return FALSE;
10862         }
10863
10864       if (info->emitrelocations)
10865         {
10866           r = get_relocs (stub_entry->group->stub_sec, 1);
10867           if (r == NULL)
10868             return FALSE;
10869           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10870           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10871           r->r_addend = dest;
10872           if (stub_entry->h != NULL)
10873             {
10874               struct elf_link_hash_entry **hashes;
10875               unsigned long symndx;
10876               struct ppc_link_hash_entry *h;
10877
10878               hashes = elf_sym_hashes (htab->params->stub_bfd);
10879               if (hashes == NULL)
10880                 {
10881                   bfd_size_type hsize;
10882
10883                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10884                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10885                   if (hashes == NULL)
10886                     return FALSE;
10887                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10888                   htab->stub_globals = 1;
10889                 }
10890               symndx = htab->stub_globals++;
10891               h = stub_entry->h;
10892               hashes[symndx] = &h->elf;
10893               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10894               if (h->oh != NULL && h->oh->is_func)
10895                 h = ppc_follow_link (h->oh);
10896               if (h->elf.root.u.def.section != stub_entry->target_section)
10897                 /* H is an opd symbol.  The addend must be zero.  */
10898                 r->r_addend = 0;
10899               else
10900                 {
10901                   off = (h->elf.root.u.def.value
10902                          + h->elf.root.u.def.section->output_offset
10903                          + h->elf.root.u.def.section->output_section->vma);
10904                   r->r_addend -= off;
10905                 }
10906             }
10907         }
10908       break;
10909
10910     case ppc_stub_plt_branch:
10911     case ppc_stub_plt_branch_r2off:
10912       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10913                                          stub_entry->root.string + 9,
10914                                          FALSE, FALSE);
10915       if (br_entry == NULL)
10916         {
10917           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10918                                   stub_entry->root.string);
10919           htab->stub_error = TRUE;
10920           return FALSE;
10921         }
10922
10923       dest = (stub_entry->target_value
10924               + stub_entry->target_section->output_offset
10925               + stub_entry->target_section->output_section->vma);
10926       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10927         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10928
10929       bfd_put_64 (htab->brlt->owner, dest,
10930                   htab->brlt->contents + br_entry->offset);
10931
10932       if (br_entry->iter == htab->stub_iteration)
10933         {
10934           br_entry->iter = 0;
10935
10936           if (htab->relbrlt != NULL)
10937             {
10938               /* Create a reloc for the branch lookup table entry.  */
10939               Elf_Internal_Rela rela;
10940               bfd_byte *rl;
10941
10942               rela.r_offset = (br_entry->offset
10943                                + htab->brlt->output_offset
10944                                + htab->brlt->output_section->vma);
10945               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10946               rela.r_addend = dest;
10947
10948               rl = htab->relbrlt->contents;
10949               rl += (htab->relbrlt->reloc_count++
10950                      * sizeof (Elf64_External_Rela));
10951               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10952             }
10953           else if (info->emitrelocations)
10954             {
10955               r = get_relocs (htab->brlt, 1);
10956               if (r == NULL)
10957                 return FALSE;
10958               /* brlt, being SEC_LINKER_CREATED does not go through the
10959                  normal reloc processing.  Symbols and offsets are not
10960                  translated from input file to output file form, so
10961                  set up the offset per the output file.  */
10962               r->r_offset = (br_entry->offset
10963                              + htab->brlt->output_offset
10964                              + htab->brlt->output_section->vma);
10965               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10966               r->r_addend = dest;
10967             }
10968         }
10969
10970       dest = (br_entry->offset
10971               + htab->brlt->output_offset
10972               + htab->brlt->output_section->vma);
10973
10974       off = (dest
10975              - elf_gp (htab->brlt->output_section->owner)
10976              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10977
10978       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10979         {
10980           info->callbacks->einfo
10981             (_("%P: linkage table error against `%T'\n"),
10982              stub_entry->root.string);
10983           bfd_set_error (bfd_error_bad_value);
10984           htab->stub_error = TRUE;
10985           return FALSE;
10986         }
10987
10988       if (info->emitrelocations)
10989         {
10990           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10991           if (r == NULL)
10992             return FALSE;
10993           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10994           if (bfd_big_endian (info->output_bfd))
10995             r[0].r_offset += 2;
10996           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10997             r[0].r_offset += 4;
10998           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10999           r[0].r_addend = dest;
11000           if (PPC_HA (off) != 0)
11001             {
11002               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11003               r[1].r_offset = r[0].r_offset + 4;
11004               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11005               r[1].r_addend = r[0].r_addend;
11006             }
11007         }
11008
11009       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11010         {
11011           if (PPC_HA (off) != 0)
11012             {
11013               size = 16;
11014               bfd_put_32 (htab->params->stub_bfd,
11015                           ADDIS_R12_R2 | PPC_HA (off), loc);
11016               loc += 4;
11017               bfd_put_32 (htab->params->stub_bfd,
11018                           LD_R12_0R12 | PPC_LO (off), loc);
11019             }
11020           else
11021             {
11022               size = 12;
11023               bfd_put_32 (htab->params->stub_bfd,
11024                           LD_R12_0R2 | PPC_LO (off), loc);
11025             }
11026         }
11027       else
11028         {
11029           bfd_vma r2off = get_r2off (info, stub_entry);
11030
11031           if (r2off == (bfd_vma) -1)
11032             {
11033               htab->stub_error = TRUE;
11034               return FALSE;
11035             }
11036
11037           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11038           loc += 4;
11039           size = 16;
11040           if (PPC_HA (off) != 0)
11041             {
11042               size += 4;
11043               bfd_put_32 (htab->params->stub_bfd,
11044                           ADDIS_R12_R2 | PPC_HA (off), loc);
11045               loc += 4;
11046               bfd_put_32 (htab->params->stub_bfd,
11047                           LD_R12_0R12 | PPC_LO (off), loc);
11048             }
11049           else
11050             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11051
11052           if (PPC_HA (r2off) != 0)
11053             {
11054               size += 4;
11055               loc += 4;
11056               bfd_put_32 (htab->params->stub_bfd,
11057                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11058             }
11059           if (PPC_LO (r2off) != 0)
11060             {
11061               size += 4;
11062               loc += 4;
11063               bfd_put_32 (htab->params->stub_bfd,
11064                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11065             }
11066         }
11067       loc += 4;
11068       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11069       loc += 4;
11070       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11071       break;
11072
11073     case ppc_stub_plt_call:
11074     case ppc_stub_plt_call_r2save:
11075       if (stub_entry->h != NULL
11076           && stub_entry->h->is_func_descriptor
11077           && stub_entry->h->oh != NULL)
11078         {
11079           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11080
11081           /* If the old-ABI "dot-symbol" is undefined make it weak so
11082              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11083           if (fh->elf.root.type == bfd_link_hash_undefined
11084               && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11085                   || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11086             fh->elf.root.type = bfd_link_hash_undefweak;
11087         }
11088
11089       /* Now build the stub.  */
11090       dest = stub_entry->plt_ent->plt.offset & ~1;
11091       if (dest >= (bfd_vma) -2)
11092         abort ();
11093
11094       plt = htab->elf.splt;
11095       if (!htab->elf.dynamic_sections_created
11096           || stub_entry->h == NULL
11097           || stub_entry->h->elf.dynindx == -1)
11098         plt = htab->elf.iplt;
11099
11100       dest += plt->output_offset + plt->output_section->vma;
11101
11102       if (stub_entry->h == NULL
11103           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11104         {
11105           Elf_Internal_Rela rela;
11106           bfd_byte *rl;
11107
11108           rela.r_offset = dest;
11109           if (htab->opd_abi)
11110             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11111           else
11112             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11113           rela.r_addend = (stub_entry->target_value
11114                            + stub_entry->target_section->output_offset
11115                            + stub_entry->target_section->output_section->vma);
11116
11117           rl = (htab->elf.irelplt->contents
11118                 + (htab->elf.irelplt->reloc_count++
11119                    * sizeof (Elf64_External_Rela)));
11120           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11121           stub_entry->plt_ent->plt.offset |= 1;
11122           htab->local_ifunc_resolver = 1;
11123         }
11124
11125       off = (dest
11126              - elf_gp (plt->output_section->owner)
11127              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11128
11129       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11130         {
11131           info->callbacks->einfo
11132             /* xgettext:c-format */
11133             (_("%P: linkage table error against `%T'\n"),
11134              stub_entry->h != NULL
11135              ? stub_entry->h->elf.root.root.string
11136              : "<local sym>");
11137           bfd_set_error (bfd_error_bad_value);
11138           htab->stub_error = TRUE;
11139           return FALSE;
11140         }
11141
11142       if (htab->params->plt_stub_align != 0)
11143         {
11144           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11145
11146           stub_entry->group->stub_sec->size += pad;
11147           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11148           loc += pad;
11149         }
11150
11151       r = NULL;
11152       if (info->emitrelocations)
11153         {
11154           r = get_relocs (stub_entry->group->stub_sec,
11155                           ((PPC_HA (off) != 0)
11156                            + (htab->opd_abi
11157                               ? 2 + (htab->params->plt_static_chain
11158                                      && PPC_HA (off + 16) == PPC_HA (off))
11159                               : 1)));
11160           if (r == NULL)
11161             return FALSE;
11162           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11163           if (bfd_big_endian (info->output_bfd))
11164             r[0].r_offset += 2;
11165           r[0].r_addend = dest;
11166         }
11167       if (stub_entry->h != NULL
11168           && (stub_entry->h == htab->tls_get_addr_fd
11169               || stub_entry->h == htab->tls_get_addr)
11170           && htab->params->tls_get_addr_opt)
11171         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11172       else
11173         p = build_plt_stub (htab, stub_entry, loc, off, r);
11174       size = p - loc;
11175       break;
11176
11177     case ppc_stub_save_res:
11178       return TRUE;
11179
11180     default:
11181       BFD_FAIL ();
11182       return FALSE;
11183     }
11184
11185   stub_entry->group->stub_sec->size += size;
11186
11187   if (htab->params->emit_stub_syms)
11188     {
11189       struct elf_link_hash_entry *h;
11190       size_t len1, len2;
11191       char *name;
11192       const char *const stub_str[] = { "long_branch",
11193                                        "long_branch_r2off",
11194                                        "plt_branch",
11195                                        "plt_branch_r2off",
11196                                        "plt_call",
11197                                        "plt_call" };
11198
11199       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11200       len2 = strlen (stub_entry->root.string);
11201       name = bfd_malloc (len1 + len2 + 2);
11202       if (name == NULL)
11203         return FALSE;
11204       memcpy (name, stub_entry->root.string, 9);
11205       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11206       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11207       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11208       if (h == NULL)
11209         return FALSE;
11210       if (h->root.type == bfd_link_hash_new)
11211         {
11212           h->root.type = bfd_link_hash_defined;
11213           h->root.u.def.section = stub_entry->group->stub_sec;
11214           h->root.u.def.value = stub_entry->stub_offset;
11215           h->ref_regular = 1;
11216           h->def_regular = 1;
11217           h->ref_regular_nonweak = 1;
11218           h->forced_local = 1;
11219           h->non_elf = 0;
11220           h->root.linker_def = 1;
11221         }
11222     }
11223
11224   return TRUE;
11225 }
11226
11227 /* As above, but don't actually build the stub.  Just bump offset so
11228    we know stub section sizes, and select plt_branch stubs where
11229    long_branch stubs won't do.  */
11230
11231 static bfd_boolean
11232 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11233 {
11234   struct ppc_stub_hash_entry *stub_entry;
11235   struct bfd_link_info *info;
11236   struct ppc_link_hash_table *htab;
11237   bfd_vma off;
11238   int size;
11239
11240   /* Massage our args to the form they really have.  */
11241   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11242   info = in_arg;
11243
11244   htab = ppc_hash_table (info);
11245   if (htab == NULL)
11246     return FALSE;
11247
11248   if (stub_entry->h != NULL
11249       && stub_entry->h->save_res
11250       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11251       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11252     {
11253       /* Don't make stubs to out-of-line register save/restore
11254          functions.  Instead, emit copies of the functions.  */
11255       stub_entry->group->needs_save_res = 1;
11256       stub_entry->stub_type = ppc_stub_save_res;
11257       return TRUE;
11258     }
11259
11260   if (stub_entry->stub_type == ppc_stub_plt_call
11261       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11262     {
11263       asection *plt;
11264       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11265       if (off >= (bfd_vma) -2)
11266         abort ();
11267       plt = htab->elf.splt;
11268       if (!htab->elf.dynamic_sections_created
11269           || stub_entry->h == NULL
11270           || stub_entry->h->elf.dynindx == -1)
11271         plt = htab->elf.iplt;
11272       off += (plt->output_offset
11273               + plt->output_section->vma
11274               - elf_gp (plt->output_section->owner)
11275               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11276
11277       size = plt_stub_size (htab, stub_entry, off);
11278       if (stub_entry->h != NULL
11279           && (stub_entry->h == htab->tls_get_addr_fd
11280               || stub_entry->h == htab->tls_get_addr)
11281           && htab->params->tls_get_addr_opt
11282           && (ALWAYS_EMIT_R2SAVE
11283               || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11284         stub_entry->group->tls_get_addr_opt_bctrl
11285           = stub_entry->group->stub_sec->size + size - 5 * 4;
11286
11287       if (htab->params->plt_stub_align)
11288         size += plt_stub_pad (htab, stub_entry, off);
11289       if (info->emitrelocations)
11290         {
11291           stub_entry->group->stub_sec->reloc_count
11292             += ((PPC_HA (off) != 0)
11293                 + (htab->opd_abi
11294                    ? 2 + (htab->params->plt_static_chain
11295                           && PPC_HA (off + 16) == PPC_HA (off))
11296                    : 1));
11297           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11298         }
11299     }
11300   else
11301     {
11302       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11303          variants.  */
11304       bfd_vma r2off = 0;
11305       bfd_vma local_off = 0;
11306
11307       off = (stub_entry->target_value
11308              + stub_entry->target_section->output_offset
11309              + stub_entry->target_section->output_section->vma);
11310       off -= (stub_entry->group->stub_sec->size
11311               + stub_entry->group->stub_sec->output_offset
11312               + stub_entry->group->stub_sec->output_section->vma);
11313
11314       /* Reset the stub type from the plt variant in case we now
11315          can reach with a shorter stub.  */
11316       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11317         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11318
11319       size = 4;
11320       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11321         {
11322           r2off = get_r2off (info, stub_entry);
11323           if (r2off == (bfd_vma) -1)
11324             {
11325               htab->stub_error = TRUE;
11326               return FALSE;
11327             }
11328           size = 8;
11329           if (PPC_HA (r2off) != 0)
11330             size += 4;
11331           if (PPC_LO (r2off) != 0)
11332             size += 4;
11333           off -= size - 4;
11334         }
11335
11336       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11337
11338       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11339          Do the same for -R objects without function descriptors.  */
11340       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11341           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11342               && r2off == 0
11343               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11344         {
11345           struct ppc_branch_hash_entry *br_entry;
11346
11347           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11348                                              stub_entry->root.string + 9,
11349                                              TRUE, FALSE);
11350           if (br_entry == NULL)
11351             {
11352               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11353                                       stub_entry->root.string);
11354               htab->stub_error = TRUE;
11355               return FALSE;
11356             }
11357
11358           if (br_entry->iter != htab->stub_iteration)
11359             {
11360               br_entry->iter = htab->stub_iteration;
11361               br_entry->offset = htab->brlt->size;
11362               htab->brlt->size += 8;
11363
11364               if (htab->relbrlt != NULL)
11365                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11366               else if (info->emitrelocations)
11367                 {
11368                   htab->brlt->reloc_count += 1;
11369                   htab->brlt->flags |= SEC_RELOC;
11370                 }
11371             }
11372
11373           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11374           off = (br_entry->offset
11375                  + htab->brlt->output_offset
11376                  + htab->brlt->output_section->vma
11377                  - elf_gp (htab->brlt->output_section->owner)
11378                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11379
11380           if (info->emitrelocations)
11381             {
11382               stub_entry->group->stub_sec->reloc_count
11383                 += 1 + (PPC_HA (off) != 0);
11384               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11385             }
11386
11387           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11388             {
11389               size = 12;
11390               if (PPC_HA (off) != 0)
11391                 size = 16;
11392             }
11393           else
11394             {
11395               size = 16;
11396               if (PPC_HA (off) != 0)
11397                 size += 4;
11398
11399               if (PPC_HA (r2off) != 0)
11400                 size += 4;
11401               if (PPC_LO (r2off) != 0)
11402                 size += 4;
11403             }
11404         }
11405       else if (info->emitrelocations)
11406         {
11407           stub_entry->group->stub_sec->reloc_count += 1;
11408           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11409         }
11410     }
11411
11412   stub_entry->group->stub_sec->size += size;
11413   return TRUE;
11414 }
11415
11416 /* Set up various things so that we can make a list of input sections
11417    for each output section included in the link.  Returns -1 on error,
11418    0 when no stubs will be needed, and 1 on success.  */
11419
11420 int
11421 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11422 {
11423   unsigned int id;
11424   bfd_size_type amt;
11425   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11426
11427   if (htab == NULL)
11428     return -1;
11429
11430   htab->sec_info_arr_size = bfd_get_next_section_id ();
11431   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11432   htab->sec_info = bfd_zmalloc (amt);
11433   if (htab->sec_info == NULL)
11434     return -1;
11435
11436   /* Set toc_off for com, und, abs and ind sections.  */
11437   for (id = 0; id < 3; id++)
11438     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11439
11440   return 1;
11441 }
11442
11443 /* Set up for first pass at multitoc partitioning.  */
11444
11445 void
11446 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11447 {
11448   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11449
11450   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11451   htab->toc_bfd = NULL;
11452   htab->toc_first_sec = NULL;
11453 }
11454
11455 /* The linker repeatedly calls this function for each TOC input section
11456    and linker generated GOT section.  Group input bfds such that the toc
11457    within a group is less than 64k in size.  */
11458
11459 bfd_boolean
11460 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11461 {
11462   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11463   bfd_vma addr, off, limit;
11464
11465   if (htab == NULL)
11466     return FALSE;
11467
11468   if (!htab->second_toc_pass)
11469     {
11470       /* Keep track of the first .toc or .got section for this input bfd.  */
11471       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11472
11473       if (new_bfd)
11474         {
11475           htab->toc_bfd = isec->owner;
11476           htab->toc_first_sec = isec;
11477         }
11478
11479       addr = isec->output_offset + isec->output_section->vma;
11480       off = addr - htab->toc_curr;
11481       limit = 0x80008000;
11482       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11483         limit = 0x10000;
11484       if (off + isec->size > limit)
11485         {
11486           addr = (htab->toc_first_sec->output_offset
11487                   + htab->toc_first_sec->output_section->vma);
11488           htab->toc_curr = addr;
11489           htab->toc_curr &= -TOC_BASE_ALIGN;
11490         }
11491
11492       /* toc_curr is the base address of this toc group.  Set elf_gp
11493          for the input section to be the offset relative to the
11494          output toc base plus 0x8000.  Making the input elf_gp an
11495          offset allows us to move the toc as a whole without
11496          recalculating input elf_gp.  */
11497       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11498       off += TOC_BASE_OFF;
11499
11500       /* Die if someone uses a linker script that doesn't keep input
11501          file .toc and .got together.  */
11502       if (new_bfd
11503           && elf_gp (isec->owner) != 0
11504           && elf_gp (isec->owner) != off)
11505         return FALSE;
11506
11507       elf_gp (isec->owner) = off;
11508       return TRUE;
11509     }
11510
11511   /* During the second pass toc_first_sec points to the start of
11512      a toc group, and toc_curr is used to track the old elf_gp.
11513      We use toc_bfd to ensure we only look at each bfd once.  */
11514   if (htab->toc_bfd == isec->owner)
11515     return TRUE;
11516   htab->toc_bfd = isec->owner;
11517
11518   if (htab->toc_first_sec == NULL
11519       || htab->toc_curr != elf_gp (isec->owner))
11520     {
11521       htab->toc_curr = elf_gp (isec->owner);
11522       htab->toc_first_sec = isec;
11523     }
11524   addr = (htab->toc_first_sec->output_offset
11525           + htab->toc_first_sec->output_section->vma);
11526   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11527   elf_gp (isec->owner) = off;
11528
11529   return TRUE;
11530 }
11531
11532 /* Called via elf_link_hash_traverse to merge GOT entries for global
11533    symbol H.  */
11534
11535 static bfd_boolean
11536 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11537 {
11538   if (h->root.type == bfd_link_hash_indirect)
11539     return TRUE;
11540
11541   merge_got_entries (&h->got.glist);
11542
11543   return TRUE;
11544 }
11545
11546 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11547    symbol H.  */
11548
11549 static bfd_boolean
11550 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11551 {
11552   struct got_entry *gent;
11553
11554   if (h->root.type == bfd_link_hash_indirect)
11555     return TRUE;
11556
11557   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11558     if (!gent->is_indirect)
11559       allocate_got (h, (struct bfd_link_info *) inf, gent);
11560   return TRUE;
11561 }
11562
11563 /* Called on the first multitoc pass after the last call to
11564    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11565    entries.  */
11566
11567 bfd_boolean
11568 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11569 {
11570   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11571   struct bfd *ibfd, *ibfd2;
11572   bfd_boolean done_something;
11573
11574   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11575
11576   if (!htab->do_multi_toc)
11577     return FALSE;
11578
11579   /* Merge global sym got entries within a toc group.  */
11580   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11581
11582   /* And tlsld_got.  */
11583   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11584     {
11585       struct got_entry *ent, *ent2;
11586
11587       if (!is_ppc64_elf (ibfd))
11588         continue;
11589
11590       ent = ppc64_tlsld_got (ibfd);
11591       if (!ent->is_indirect
11592           && ent->got.offset != (bfd_vma) -1)
11593         {
11594           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11595             {
11596               if (!is_ppc64_elf (ibfd2))
11597                 continue;
11598
11599               ent2 = ppc64_tlsld_got (ibfd2);
11600               if (!ent2->is_indirect
11601                   && ent2->got.offset != (bfd_vma) -1
11602                   && elf_gp (ibfd2) == elf_gp (ibfd))
11603                 {
11604                   ent2->is_indirect = TRUE;
11605                   ent2->got.ent = ent;
11606                 }
11607             }
11608         }
11609     }
11610
11611   /* Zap sizes of got sections.  */
11612   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11613   htab->elf.irelplt->size -= htab->got_reli_size;
11614   htab->got_reli_size = 0;
11615
11616   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11617     {
11618       asection *got, *relgot;
11619
11620       if (!is_ppc64_elf (ibfd))
11621         continue;
11622
11623       got = ppc64_elf_tdata (ibfd)->got;
11624       if (got != NULL)
11625         {
11626           got->rawsize = got->size;
11627           got->size = 0;
11628           relgot = ppc64_elf_tdata (ibfd)->relgot;
11629           relgot->rawsize = relgot->size;
11630           relgot->size = 0;
11631         }
11632     }
11633
11634   /* Now reallocate the got, local syms first.  We don't need to
11635      allocate section contents again since we never increase size.  */
11636   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11637     {
11638       struct got_entry **lgot_ents;
11639       struct got_entry **end_lgot_ents;
11640       struct plt_entry **local_plt;
11641       struct plt_entry **end_local_plt;
11642       unsigned char *lgot_masks;
11643       bfd_size_type locsymcount;
11644       Elf_Internal_Shdr *symtab_hdr;
11645       asection *s;
11646
11647       if (!is_ppc64_elf (ibfd))
11648         continue;
11649
11650       lgot_ents = elf_local_got_ents (ibfd);
11651       if (!lgot_ents)
11652         continue;
11653
11654       symtab_hdr = &elf_symtab_hdr (ibfd);
11655       locsymcount = symtab_hdr->sh_info;
11656       end_lgot_ents = lgot_ents + locsymcount;
11657       local_plt = (struct plt_entry **) end_lgot_ents;
11658       end_local_plt = local_plt + locsymcount;
11659       lgot_masks = (unsigned char *) end_local_plt;
11660       s = ppc64_elf_tdata (ibfd)->got;
11661       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11662         {
11663           struct got_entry *ent;
11664
11665           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11666             {
11667               unsigned int ent_size = 8;
11668               unsigned int rel_size = sizeof (Elf64_External_Rela);
11669
11670               ent->got.offset = s->size;
11671               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11672                 {
11673                   ent_size *= 2;
11674                   rel_size *= 2;
11675                 }
11676               s->size += ent_size;
11677               if ((*lgot_masks & PLT_IFUNC) != 0)
11678                 {
11679                   htab->elf.irelplt->size += rel_size;
11680                   htab->got_reli_size += rel_size;
11681                 }
11682               else if (bfd_link_pic (info))
11683                 {
11684                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11685                   srel->size += rel_size;
11686                 }
11687             }
11688         }
11689     }
11690
11691   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11692
11693   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11694     {
11695       struct got_entry *ent;
11696
11697       if (!is_ppc64_elf (ibfd))
11698         continue;
11699
11700       ent = ppc64_tlsld_got (ibfd);
11701       if (!ent->is_indirect
11702           && ent->got.offset != (bfd_vma) -1)
11703         {
11704           asection *s = ppc64_elf_tdata (ibfd)->got;
11705           ent->got.offset = s->size;
11706           s->size += 16;
11707           if (bfd_link_pic (info))
11708             {
11709               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11710               srel->size += sizeof (Elf64_External_Rela);
11711             }
11712         }
11713     }
11714
11715   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11716   if (!done_something)
11717     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11718       {
11719         asection *got;
11720
11721         if (!is_ppc64_elf (ibfd))
11722           continue;
11723
11724         got = ppc64_elf_tdata (ibfd)->got;
11725         if (got != NULL)
11726           {
11727             done_something = got->rawsize != got->size;
11728             if (done_something)
11729               break;
11730           }
11731       }
11732
11733   if (done_something)
11734     (*htab->params->layout_sections_again) ();
11735
11736   /* Set up for second pass over toc sections to recalculate elf_gp
11737      on input sections.  */
11738   htab->toc_bfd = NULL;
11739   htab->toc_first_sec = NULL;
11740   htab->second_toc_pass = TRUE;
11741   return done_something;
11742 }
11743
11744 /* Called after second pass of multitoc partitioning.  */
11745
11746 void
11747 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11748 {
11749   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11750
11751   /* After the second pass, toc_curr tracks the TOC offset used
11752      for code sections below in ppc64_elf_next_input_section.  */
11753   htab->toc_curr = TOC_BASE_OFF;
11754 }
11755
11756 /* No toc references were found in ISEC.  If the code in ISEC makes no
11757    calls, then there's no need to use toc adjusting stubs when branching
11758    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11759    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11760    needed, and 2 if a cyclical call-graph was found but no other reason
11761    for a stub was detected.  If called from the top level, a return of
11762    2 means the same as a return of 0.  */
11763
11764 static int
11765 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11766 {
11767   int ret;
11768
11769   /* Mark this section as checked.  */
11770   isec->call_check_done = 1;
11771
11772   /* We know none of our code bearing sections will need toc stubs.  */
11773   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11774     return 0;
11775
11776   if (isec->size == 0)
11777     return 0;
11778
11779   if (isec->output_section == NULL)
11780     return 0;
11781
11782   ret = 0;
11783   if (isec->reloc_count != 0)
11784     {
11785       Elf_Internal_Rela *relstart, *rel;
11786       Elf_Internal_Sym *local_syms;
11787       struct ppc_link_hash_table *htab;
11788
11789       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11790                                             info->keep_memory);
11791       if (relstart == NULL)
11792         return -1;
11793
11794       /* Look for branches to outside of this section.  */
11795       local_syms = NULL;
11796       htab = ppc_hash_table (info);
11797       if (htab == NULL)
11798         return -1;
11799
11800       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11801         {
11802           enum elf_ppc64_reloc_type r_type;
11803           unsigned long r_symndx;
11804           struct elf_link_hash_entry *h;
11805           struct ppc_link_hash_entry *eh;
11806           Elf_Internal_Sym *sym;
11807           asection *sym_sec;
11808           struct _opd_sec_data *opd;
11809           bfd_vma sym_value;
11810           bfd_vma dest;
11811
11812           r_type = ELF64_R_TYPE (rel->r_info);
11813           if (r_type != R_PPC64_REL24
11814               && r_type != R_PPC64_REL14
11815               && r_type != R_PPC64_REL14_BRTAKEN
11816               && r_type != R_PPC64_REL14_BRNTAKEN)
11817             continue;
11818
11819           r_symndx = ELF64_R_SYM (rel->r_info);
11820           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11821                           isec->owner))
11822             {
11823               ret = -1;
11824               break;
11825             }
11826
11827           /* Calls to dynamic lib functions go through a plt call stub
11828              that uses r2.  */
11829           eh = (struct ppc_link_hash_entry *) h;
11830           if (eh != NULL
11831               && (eh->elf.plt.plist != NULL
11832                   || (eh->oh != NULL
11833                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11834             {
11835               ret = 1;
11836               break;
11837             }
11838
11839           if (sym_sec == NULL)
11840             /* Ignore other undefined symbols.  */
11841             continue;
11842
11843           /* Assume branches to other sections not included in the
11844              link need stubs too, to cover -R and absolute syms.  */
11845           if (sym_sec->output_section == NULL)
11846             {
11847               ret = 1;
11848               break;
11849             }
11850
11851           if (h == NULL)
11852             sym_value = sym->st_value;
11853           else
11854             {
11855               if (h->root.type != bfd_link_hash_defined
11856                   && h->root.type != bfd_link_hash_defweak)
11857                 abort ();
11858               sym_value = h->root.u.def.value;
11859             }
11860           sym_value += rel->r_addend;
11861
11862           /* If this branch reloc uses an opd sym, find the code section.  */
11863           opd = get_opd_info (sym_sec);
11864           if (opd != NULL)
11865             {
11866               if (h == NULL && opd->adjust != NULL)
11867                 {
11868                   long adjust;
11869
11870                   adjust = opd->adjust[OPD_NDX (sym_value)];
11871                   if (adjust == -1)
11872                     /* Assume deleted functions won't ever be called.  */
11873                     continue;
11874                   sym_value += adjust;
11875                 }
11876
11877               dest = opd_entry_value (sym_sec, sym_value,
11878                                       &sym_sec, NULL, FALSE);
11879               if (dest == (bfd_vma) -1)
11880                 continue;
11881             }
11882           else
11883             dest = (sym_value
11884                     + sym_sec->output_offset
11885                     + sym_sec->output_section->vma);
11886
11887           /* Ignore branch to self.  */
11888           if (sym_sec == isec)
11889             continue;
11890
11891           /* If the called function uses the toc, we need a stub.  */
11892           if (sym_sec->has_toc_reloc
11893               || sym_sec->makes_toc_func_call)
11894             {
11895               ret = 1;
11896               break;
11897             }
11898
11899           /* Assume any branch that needs a long branch stub might in fact
11900              need a plt_branch stub.  A plt_branch stub uses r2.  */
11901           else if (dest - (isec->output_offset
11902                            + isec->output_section->vma
11903                            + rel->r_offset) + (1 << 25)
11904                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11905                                                              ? h->other
11906                                                              : sym->st_other))
11907             {
11908               ret = 1;
11909               break;
11910             }
11911
11912           /* If calling back to a section in the process of being
11913              tested, we can't say for sure that no toc adjusting stubs
11914              are needed, so don't return zero.  */
11915           else if (sym_sec->call_check_in_progress)
11916             ret = 2;
11917
11918           /* Branches to another section that itself doesn't have any TOC
11919              references are OK.  Recursively call ourselves to check.  */
11920           else if (!sym_sec->call_check_done)
11921             {
11922               int recur;
11923
11924               /* Mark current section as indeterminate, so that other
11925                  sections that call back to current won't be marked as
11926                  known.  */
11927               isec->call_check_in_progress = 1;
11928               recur = toc_adjusting_stub_needed (info, sym_sec);
11929               isec->call_check_in_progress = 0;
11930
11931               if (recur != 0)
11932                 {
11933                   ret = recur;
11934                   if (recur != 2)
11935                     break;
11936                 }
11937             }
11938         }
11939
11940       if (local_syms != NULL
11941           && (elf_symtab_hdr (isec->owner).contents
11942               != (unsigned char *) local_syms))
11943         free (local_syms);
11944       if (elf_section_data (isec)->relocs != relstart)
11945         free (relstart);
11946     }
11947
11948   if ((ret & 1) == 0
11949       && isec->map_head.s != NULL
11950       && (strcmp (isec->output_section->name, ".init") == 0
11951           || strcmp (isec->output_section->name, ".fini") == 0))
11952     {
11953       if (isec->map_head.s->has_toc_reloc
11954           || isec->map_head.s->makes_toc_func_call)
11955         ret = 1;
11956       else if (!isec->map_head.s->call_check_done)
11957         {
11958           int recur;
11959           isec->call_check_in_progress = 1;
11960           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11961           isec->call_check_in_progress = 0;
11962           if (recur != 0)
11963             ret = recur;
11964         }
11965     }
11966
11967   if (ret == 1)
11968     isec->makes_toc_func_call = 1;
11969
11970   return ret;
11971 }
11972
11973 /* The linker repeatedly calls this function for each input section,
11974    in the order that input sections are linked into output sections.
11975    Build lists of input sections to determine groupings between which
11976    we may insert linker stubs.  */
11977
11978 bfd_boolean
11979 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11980 {
11981   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11982
11983   if (htab == NULL)
11984     return FALSE;
11985
11986   if ((isec->output_section->flags & SEC_CODE) != 0
11987       && isec->output_section->id < htab->sec_info_arr_size)
11988     {
11989       /* This happens to make the list in reverse order,
11990          which is what we want.  */
11991       htab->sec_info[isec->id].u.list
11992         = htab->sec_info[isec->output_section->id].u.list;
11993       htab->sec_info[isec->output_section->id].u.list = isec;
11994     }
11995
11996   if (htab->multi_toc_needed)
11997     {
11998       /* Analyse sections that aren't already flagged as needing a
11999          valid toc pointer.  Exclude .fixup for the linux kernel.
12000          .fixup contains branches, but only back to the function that
12001          hit an exception.  */
12002       if (!(isec->has_toc_reloc
12003             || (isec->flags & SEC_CODE) == 0
12004             || strcmp (isec->name, ".fixup") == 0
12005             || isec->call_check_done))
12006         {
12007           if (toc_adjusting_stub_needed (info, isec) < 0)
12008             return FALSE;
12009         }
12010       /* Make all sections use the TOC assigned for this object file.
12011          This will be wrong for pasted sections;  We fix that in
12012          check_pasted_section().  */
12013       if (elf_gp (isec->owner) != 0)
12014         htab->toc_curr = elf_gp (isec->owner);
12015     }
12016
12017   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12018   return TRUE;
12019 }
12020
12021 /* Check that all .init and .fini sections use the same toc, if they
12022    have toc relocs.  */
12023
12024 static bfd_boolean
12025 check_pasted_section (struct bfd_link_info *info, const char *name)
12026 {
12027   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12028
12029   if (o != NULL)
12030     {
12031       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12032       bfd_vma toc_off = 0;
12033       asection *i;
12034
12035       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12036         if (i->has_toc_reloc)
12037           {
12038             if (toc_off == 0)
12039               toc_off = htab->sec_info[i->id].toc_off;
12040             else if (toc_off != htab->sec_info[i->id].toc_off)
12041               return FALSE;
12042           }
12043
12044       if (toc_off == 0)
12045         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12046           if (i->makes_toc_func_call)
12047             {
12048               toc_off = htab->sec_info[i->id].toc_off;
12049               break;
12050             }
12051
12052       /* Make sure the whole pasted function uses the same toc offset.  */
12053       if (toc_off != 0)
12054         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12055           htab->sec_info[i->id].toc_off = toc_off;
12056     }
12057   return TRUE;
12058 }
12059
12060 bfd_boolean
12061 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12062 {
12063   return (check_pasted_section (info, ".init")
12064           & check_pasted_section (info, ".fini"));
12065 }
12066
12067 /* See whether we can group stub sections together.  Grouping stub
12068    sections may result in fewer stubs.  More importantly, we need to
12069    put all .init* and .fini* stubs at the beginning of the .init or
12070    .fini output sections respectively, because glibc splits the
12071    _init and _fini functions into multiple parts.  Putting a stub in
12072    the middle of a function is not a good idea.  */
12073
12074 static bfd_boolean
12075 group_sections (struct bfd_link_info *info,
12076                 bfd_size_type stub_group_size,
12077                 bfd_boolean stubs_always_before_branch)
12078 {
12079   struct ppc_link_hash_table *htab;
12080   asection *osec;
12081   bfd_boolean suppress_size_errors;
12082
12083   htab = ppc_hash_table (info);
12084   if (htab == NULL)
12085     return FALSE;
12086
12087   suppress_size_errors = FALSE;
12088   if (stub_group_size == 1)
12089     {
12090       /* Default values.  */
12091       if (stubs_always_before_branch)
12092         stub_group_size = 0x1e00000;
12093       else
12094         stub_group_size = 0x1c00000;
12095       suppress_size_errors = TRUE;
12096     }
12097
12098   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12099     {
12100       asection *tail;
12101
12102       if (osec->id >= htab->sec_info_arr_size)
12103         continue;
12104
12105       tail = htab->sec_info[osec->id].u.list;
12106       while (tail != NULL)
12107         {
12108           asection *curr;
12109           asection *prev;
12110           bfd_size_type total;
12111           bfd_boolean big_sec;
12112           bfd_vma curr_toc;
12113           struct map_stub *group;
12114           bfd_size_type group_size;
12115
12116           curr = tail;
12117           total = tail->size;
12118           group_size = (ppc64_elf_section_data (tail) != NULL
12119                         && ppc64_elf_section_data (tail)->has_14bit_branch
12120                         ? stub_group_size >> 10 : stub_group_size);
12121
12122           big_sec = total > group_size;
12123           if (big_sec && !suppress_size_errors)
12124             /* xgettext:c-format */
12125             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12126                                 tail->owner, tail);
12127           curr_toc = htab->sec_info[tail->id].toc_off;
12128
12129           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12130                  && ((total += curr->output_offset - prev->output_offset)
12131                      < (ppc64_elf_section_data (prev) != NULL
12132                         && ppc64_elf_section_data (prev)->has_14bit_branch
12133                         ? (group_size = stub_group_size >> 10) : group_size))
12134                  && htab->sec_info[prev->id].toc_off == curr_toc)
12135             curr = prev;
12136
12137           /* OK, the size from the start of CURR to the end is less
12138              than group_size and thus can be handled by one stub
12139              section.  (or the tail section is itself larger than
12140              group_size, in which case we may be toast.)  We should
12141              really be keeping track of the total size of stubs added
12142              here, as stubs contribute to the final output section
12143              size.  That's a little tricky, and this way will only
12144              break if stubs added make the total size more than 2^25,
12145              ie. for the default stub_group_size, if stubs total more
12146              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12147           group = bfd_alloc (curr->owner, sizeof (*group));
12148           if (group == NULL)
12149             return FALSE;
12150           group->link_sec = curr;
12151           group->stub_sec = NULL;
12152           group->needs_save_res = 0;
12153           group->tls_get_addr_opt_bctrl = -1u;
12154           group->next = htab->group;
12155           htab->group = group;
12156           do
12157             {
12158               prev = htab->sec_info[tail->id].u.list;
12159               /* Set up this stub group.  */
12160               htab->sec_info[tail->id].u.group = group;
12161             }
12162           while (tail != curr && (tail = prev) != NULL);
12163
12164           /* But wait, there's more!  Input sections up to group_size
12165              bytes before the stub section can be handled by it too.
12166              Don't do this if we have a really large section after the
12167              stubs, as adding more stubs increases the chance that
12168              branches may not reach into the stub section.  */
12169           if (!stubs_always_before_branch && !big_sec)
12170             {
12171               total = 0;
12172               while (prev != NULL
12173                      && ((total += tail->output_offset - prev->output_offset)
12174                          < (ppc64_elf_section_data (prev) != NULL
12175                             && ppc64_elf_section_data (prev)->has_14bit_branch
12176                             ? (group_size = stub_group_size >> 10) : group_size))
12177                      && htab->sec_info[prev->id].toc_off == curr_toc)
12178                 {
12179                   tail = prev;
12180                   prev = htab->sec_info[tail->id].u.list;
12181                   htab->sec_info[tail->id].u.group = group;
12182                 }
12183             }
12184           tail = prev;
12185         }
12186     }
12187   return TRUE;
12188 }
12189
12190 static const unsigned char glink_eh_frame_cie[] =
12191 {
12192   0, 0, 0, 16,                          /* length.  */
12193   0, 0, 0, 0,                           /* id.  */
12194   1,                                    /* CIE version.  */
12195   'z', 'R', 0,                          /* Augmentation string.  */
12196   4,                                    /* Code alignment.  */
12197   0x78,                                 /* Data alignment.  */
12198   65,                                   /* RA reg.  */
12199   1,                                    /* Augmentation size.  */
12200   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12201   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
12202 };
12203
12204 static size_t
12205 stub_eh_frame_size (struct map_stub *group, size_t align)
12206 {
12207   size_t this_size = 17;
12208   if (group->tls_get_addr_opt_bctrl != -1u)
12209     {
12210       unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12211       if (to_bctrl < 64)
12212         this_size += 1;
12213       else if (to_bctrl < 256)
12214         this_size += 2;
12215       else if (to_bctrl < 65536)
12216         this_size += 3;
12217       else
12218         this_size += 5;
12219       this_size += 6;
12220     }
12221   this_size = (this_size + align - 1) & -align;
12222   return this_size;
12223 }
12224
12225 /* Stripping output sections is normally done before dynamic section
12226    symbols have been allocated.  This function is called later, and
12227    handles cases like htab->brlt which is mapped to its own output
12228    section.  */
12229
12230 static void
12231 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12232 {
12233   if (isec->size == 0
12234       && isec->output_section->size == 0
12235       && !(isec->output_section->flags & SEC_KEEP)
12236       && !bfd_section_removed_from_list (info->output_bfd,
12237                                          isec->output_section)
12238       && elf_section_data (isec->output_section)->dynindx == 0)
12239     {
12240       isec->output_section->flags |= SEC_EXCLUDE;
12241       bfd_section_list_remove (info->output_bfd, isec->output_section);
12242       info->output_bfd->section_count--;
12243     }
12244 }
12245
12246 /* Determine and set the size of the stub section for a final link.
12247
12248    The basic idea here is to examine all the relocations looking for
12249    PC-relative calls to a target that is unreachable with a "bl"
12250    instruction.  */
12251
12252 bfd_boolean
12253 ppc64_elf_size_stubs (struct bfd_link_info *info)
12254 {
12255   bfd_size_type stub_group_size;
12256   bfd_boolean stubs_always_before_branch;
12257   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12258
12259   if (htab == NULL)
12260     return FALSE;
12261
12262   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12263     htab->params->plt_thread_safe = 1;
12264   if (!htab->opd_abi)
12265     htab->params->plt_thread_safe = 0;
12266   else if (htab->params->plt_thread_safe == -1)
12267     {
12268       static const char *const thread_starter[] =
12269         {
12270           "pthread_create",
12271           /* libstdc++ */
12272           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12273           /* librt */
12274           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12275           "mq_notify", "create_timer",
12276           /* libanl */
12277           "getaddrinfo_a",
12278           /* libgomp */
12279           "GOMP_parallel",
12280           "GOMP_parallel_start",
12281           "GOMP_parallel_loop_static",
12282           "GOMP_parallel_loop_static_start",
12283           "GOMP_parallel_loop_dynamic",
12284           "GOMP_parallel_loop_dynamic_start",
12285           "GOMP_parallel_loop_guided",
12286           "GOMP_parallel_loop_guided_start",
12287           "GOMP_parallel_loop_runtime",
12288           "GOMP_parallel_loop_runtime_start",
12289           "GOMP_parallel_sections",
12290           "GOMP_parallel_sections_start",
12291           /* libgo */
12292           "__go_go",
12293         };
12294       unsigned i;
12295
12296       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12297         {
12298           struct elf_link_hash_entry *h;
12299           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12300                                     FALSE, FALSE, TRUE);
12301           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12302           if (htab->params->plt_thread_safe)
12303             break;
12304         }
12305     }
12306   stubs_always_before_branch = htab->params->group_size < 0;
12307   if (htab->params->group_size < 0)
12308     stub_group_size = -htab->params->group_size;
12309   else
12310     stub_group_size = htab->params->group_size;
12311
12312   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12313     return FALSE;
12314
12315 #define STUB_SHRINK_ITER 20
12316   /* Loop until no stubs added.  After iteration 20 of this loop we may
12317      exit on a stub section shrinking.  This is to break out of a
12318      pathological case where adding stubs on one iteration decreases
12319      section gaps (perhaps due to alignment), which then requires
12320      fewer or smaller stubs on the next iteration.  */
12321
12322   while (1)
12323     {
12324       bfd *input_bfd;
12325       unsigned int bfd_indx;
12326       struct map_stub *group;
12327
12328       htab->stub_iteration += 1;
12329
12330       for (input_bfd = info->input_bfds, bfd_indx = 0;
12331            input_bfd != NULL;
12332            input_bfd = input_bfd->link.next, bfd_indx++)
12333         {
12334           Elf_Internal_Shdr *symtab_hdr;
12335           asection *section;
12336           Elf_Internal_Sym *local_syms = NULL;
12337
12338           if (!is_ppc64_elf (input_bfd))
12339             continue;
12340
12341           /* We'll need the symbol table in a second.  */
12342           symtab_hdr = &elf_symtab_hdr (input_bfd);
12343           if (symtab_hdr->sh_info == 0)
12344             continue;
12345
12346           /* Walk over each section attached to the input bfd.  */
12347           for (section = input_bfd->sections;
12348                section != NULL;
12349                section = section->next)
12350             {
12351               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12352
12353               /* If there aren't any relocs, then there's nothing more
12354                  to do.  */
12355               if ((section->flags & SEC_RELOC) == 0
12356                   || (section->flags & SEC_ALLOC) == 0
12357                   || (section->flags & SEC_LOAD) == 0
12358                   || (section->flags & SEC_CODE) == 0
12359                   || section->reloc_count == 0)
12360                 continue;
12361
12362               /* If this section is a link-once section that will be
12363                  discarded, then don't create any stubs.  */
12364               if (section->output_section == NULL
12365                   || section->output_section->owner != info->output_bfd)
12366                 continue;
12367
12368               /* Get the relocs.  */
12369               internal_relocs
12370                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12371                                              info->keep_memory);
12372               if (internal_relocs == NULL)
12373                 goto error_ret_free_local;
12374
12375               /* Now examine each relocation.  */
12376               irela = internal_relocs;
12377               irelaend = irela + section->reloc_count;
12378               for (; irela < irelaend; irela++)
12379                 {
12380                   enum elf_ppc64_reloc_type r_type;
12381                   unsigned int r_indx;
12382                   enum ppc_stub_type stub_type;
12383                   struct ppc_stub_hash_entry *stub_entry;
12384                   asection *sym_sec, *code_sec;
12385                   bfd_vma sym_value, code_value;
12386                   bfd_vma destination;
12387                   unsigned long local_off;
12388                   bfd_boolean ok_dest;
12389                   struct ppc_link_hash_entry *hash;
12390                   struct ppc_link_hash_entry *fdh;
12391                   struct elf_link_hash_entry *h;
12392                   Elf_Internal_Sym *sym;
12393                   char *stub_name;
12394                   const asection *id_sec;
12395                   struct _opd_sec_data *opd;
12396                   struct plt_entry *plt_ent;
12397
12398                   r_type = ELF64_R_TYPE (irela->r_info);
12399                   r_indx = ELF64_R_SYM (irela->r_info);
12400
12401                   if (r_type >= R_PPC64_max)
12402                     {
12403                       bfd_set_error (bfd_error_bad_value);
12404                       goto error_ret_free_internal;
12405                     }
12406
12407                   /* Only look for stubs on branch instructions.  */
12408                   if (r_type != R_PPC64_REL24
12409                       && r_type != R_PPC64_REL14
12410                       && r_type != R_PPC64_REL14_BRTAKEN
12411                       && r_type != R_PPC64_REL14_BRNTAKEN)
12412                     continue;
12413
12414                   /* Now determine the call target, its name, value,
12415                      section.  */
12416                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12417                                   r_indx, input_bfd))
12418                     goto error_ret_free_internal;
12419                   hash = (struct ppc_link_hash_entry *) h;
12420
12421                   ok_dest = FALSE;
12422                   fdh = NULL;
12423                   sym_value = 0;
12424                   if (hash == NULL)
12425                     {
12426                       sym_value = sym->st_value;
12427                       if (sym_sec != NULL
12428                           && sym_sec->output_section != NULL)
12429                         ok_dest = TRUE;
12430                     }
12431                   else if (hash->elf.root.type == bfd_link_hash_defined
12432                            || hash->elf.root.type == bfd_link_hash_defweak)
12433                     {
12434                       sym_value = hash->elf.root.u.def.value;
12435                       if (sym_sec->output_section != NULL)
12436                         ok_dest = TRUE;
12437                     }
12438                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12439                            || hash->elf.root.type == bfd_link_hash_undefined)
12440                     {
12441                       /* Recognise an old ABI func code entry sym, and
12442                          use the func descriptor sym instead if it is
12443                          defined.  */
12444                       if (hash->elf.root.root.string[0] == '.'
12445                           && hash->oh != NULL)
12446                         {
12447                           fdh = ppc_follow_link (hash->oh);
12448                           if (fdh->elf.root.type == bfd_link_hash_defined
12449                               || fdh->elf.root.type == bfd_link_hash_defweak)
12450                             {
12451                               sym_sec = fdh->elf.root.u.def.section;
12452                               sym_value = fdh->elf.root.u.def.value;
12453                               if (sym_sec->output_section != NULL)
12454                                 ok_dest = TRUE;
12455                             }
12456                           else
12457                             fdh = NULL;
12458                         }
12459                     }
12460                   else
12461                     {
12462                       bfd_set_error (bfd_error_bad_value);
12463                       goto error_ret_free_internal;
12464                     }
12465
12466                   destination = 0;
12467                   local_off = 0;
12468                   if (ok_dest)
12469                     {
12470                       sym_value += irela->r_addend;
12471                       destination = (sym_value
12472                                      + sym_sec->output_offset
12473                                      + sym_sec->output_section->vma);
12474                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12475                                                             ? hash->elf.other
12476                                                             : sym->st_other);
12477                     }
12478
12479                   code_sec = sym_sec;
12480                   code_value = sym_value;
12481                   opd = get_opd_info (sym_sec);
12482                   if (opd != NULL)
12483                     {
12484                       bfd_vma dest;
12485
12486                       if (hash == NULL && opd->adjust != NULL)
12487                         {
12488                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12489                           if (adjust == -1)
12490                             continue;
12491                           code_value += adjust;
12492                           sym_value += adjust;
12493                         }
12494                       dest = opd_entry_value (sym_sec, sym_value,
12495                                               &code_sec, &code_value, FALSE);
12496                       if (dest != (bfd_vma) -1)
12497                         {
12498                           destination = dest;
12499                           if (fdh != NULL)
12500                             {
12501                               /* Fixup old ABI sym to point at code
12502                                  entry.  */
12503                               hash->elf.root.type = bfd_link_hash_defweak;
12504                               hash->elf.root.u.def.section = code_sec;
12505                               hash->elf.root.u.def.value = code_value;
12506                             }
12507                         }
12508                     }
12509
12510                   /* Determine what (if any) linker stub is needed.  */
12511                   plt_ent = NULL;
12512                   stub_type = ppc_type_of_stub (section, irela, &hash,
12513                                                 &plt_ent, destination,
12514                                                 local_off);
12515
12516                   if (stub_type != ppc_stub_plt_call)
12517                     {
12518                       /* Check whether we need a TOC adjusting stub.
12519                          Since the linker pastes together pieces from
12520                          different object files when creating the
12521                          _init and _fini functions, it may be that a
12522                          call to what looks like a local sym is in
12523                          fact a call needing a TOC adjustment.  */
12524                       if (code_sec != NULL
12525                           && code_sec->output_section != NULL
12526                           && (htab->sec_info[code_sec->id].toc_off
12527                               != htab->sec_info[section->id].toc_off)
12528                           && (code_sec->has_toc_reloc
12529                               || code_sec->makes_toc_func_call))
12530                         stub_type = ppc_stub_long_branch_r2off;
12531                     }
12532
12533                   if (stub_type == ppc_stub_none)
12534                     continue;
12535
12536                   /* __tls_get_addr calls might be eliminated.  */
12537                   if (stub_type != ppc_stub_plt_call
12538                       && hash != NULL
12539                       && (hash == htab->tls_get_addr
12540                           || hash == htab->tls_get_addr_fd)
12541                       && section->has_tls_reloc
12542                       && irela != internal_relocs)
12543                     {
12544                       /* Get tls info.  */
12545                       unsigned char *tls_mask;
12546
12547                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12548                                          irela - 1, input_bfd))
12549                         goto error_ret_free_internal;
12550                       if (*tls_mask != 0)
12551                         continue;
12552                     }
12553
12554                   if (stub_type == ppc_stub_plt_call)
12555                     {
12556                       if (!htab->opd_abi
12557                           && htab->params->plt_localentry0 != 0
12558                           && is_elfv2_localentry0 (&hash->elf))
12559                         htab->has_plt_localentry0 = 1;
12560                       else if (irela + 1 < irelaend
12561                                && irela[1].r_offset == irela->r_offset + 4
12562                                && (ELF64_R_TYPE (irela[1].r_info)
12563                                    == R_PPC64_TOCSAVE))
12564                         {
12565                           if (!tocsave_find (htab, INSERT,
12566                                              &local_syms, irela + 1, input_bfd))
12567                             goto error_ret_free_internal;
12568                         }
12569                       else
12570                         stub_type = ppc_stub_plt_call_r2save;
12571                     }
12572
12573                   /* Support for grouping stub sections.  */
12574                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12575
12576                   /* Get the name of this stub.  */
12577                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12578                   if (!stub_name)
12579                     goto error_ret_free_internal;
12580
12581                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12582                                                      stub_name, FALSE, FALSE);
12583                   if (stub_entry != NULL)
12584                     {
12585                       /* The proper stub has already been created.  */
12586                       free (stub_name);
12587                       if (stub_type == ppc_stub_plt_call_r2save)
12588                         stub_entry->stub_type = stub_type;
12589                       continue;
12590                     }
12591
12592                   stub_entry = ppc_add_stub (stub_name, section, info);
12593                   if (stub_entry == NULL)
12594                     {
12595                       free (stub_name);
12596                     error_ret_free_internal:
12597                       if (elf_section_data (section)->relocs == NULL)
12598                         free (internal_relocs);
12599                     error_ret_free_local:
12600                       if (local_syms != NULL
12601                           && (symtab_hdr->contents
12602                               != (unsigned char *) local_syms))
12603                         free (local_syms);
12604                       return FALSE;
12605                     }
12606
12607                   stub_entry->stub_type = stub_type;
12608                   if (stub_type != ppc_stub_plt_call
12609                       && stub_type != ppc_stub_plt_call_r2save)
12610                     {
12611                       stub_entry->target_value = code_value;
12612                       stub_entry->target_section = code_sec;
12613                     }
12614                   else
12615                     {
12616                       stub_entry->target_value = sym_value;
12617                       stub_entry->target_section = sym_sec;
12618                     }
12619                   stub_entry->h = hash;
12620                   stub_entry->plt_ent = plt_ent;
12621                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12622
12623                   if (stub_entry->h != NULL)
12624                     htab->stub_globals += 1;
12625                 }
12626
12627               /* We're done with the internal relocs, free them.  */
12628               if (elf_section_data (section)->relocs != internal_relocs)
12629                 free (internal_relocs);
12630             }
12631
12632           if (local_syms != NULL
12633               && symtab_hdr->contents != (unsigned char *) local_syms)
12634             {
12635               if (!info->keep_memory)
12636                 free (local_syms);
12637               else
12638                 symtab_hdr->contents = (unsigned char *) local_syms;
12639             }
12640         }
12641
12642       /* We may have added some stubs.  Find out the new size of the
12643          stub sections.  */
12644       for (group = htab->group; group != NULL; group = group->next)
12645         if (group->stub_sec != NULL)
12646           {
12647             asection *stub_sec = group->stub_sec;
12648
12649             if (htab->stub_iteration <= STUB_SHRINK_ITER
12650                 || stub_sec->rawsize < stub_sec->size)
12651               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12652               stub_sec->rawsize = stub_sec->size;
12653             stub_sec->size = 0;
12654             stub_sec->reloc_count = 0;
12655             stub_sec->flags &= ~SEC_RELOC;
12656           }
12657
12658       htab->brlt->size = 0;
12659       htab->brlt->reloc_count = 0;
12660       htab->brlt->flags &= ~SEC_RELOC;
12661       if (htab->relbrlt != NULL)
12662         htab->relbrlt->size = 0;
12663
12664       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12665
12666       for (group = htab->group; group != NULL; group = group->next)
12667         if (group->needs_save_res)
12668           group->stub_sec->size += htab->sfpr->size;
12669
12670       if (info->emitrelocations
12671           && htab->glink != NULL && htab->glink->size != 0)
12672         {
12673           htab->glink->reloc_count = 1;
12674           htab->glink->flags |= SEC_RELOC;
12675         }
12676
12677       if (htab->glink_eh_frame != NULL
12678           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12679           && htab->glink_eh_frame->output_section->size != 0)
12680         {
12681           size_t size = 0, align = 4;
12682
12683           for (group = htab->group; group != NULL; group = group->next)
12684             if (group->stub_sec != NULL)
12685               size += stub_eh_frame_size (group, align);
12686           if (htab->glink != NULL && htab->glink->size != 0)
12687             size += (24 + align - 1) & -align;
12688           if (size != 0)
12689             size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12690           align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12691           size = (size + align - 1) & -align;
12692           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12693           htab->glink_eh_frame->size = size;
12694         }
12695
12696       if (htab->params->plt_stub_align != 0)
12697         for (group = htab->group; group != NULL; group = group->next)
12698           if (group->stub_sec != NULL)
12699             group->stub_sec->size = ((group->stub_sec->size
12700                                       + (1 << htab->params->plt_stub_align) - 1)
12701                                      & -(1 << htab->params->plt_stub_align));
12702
12703       for (group = htab->group; group != NULL; group = group->next)
12704         if (group->stub_sec != NULL
12705             && group->stub_sec->rawsize != group->stub_sec->size
12706             && (htab->stub_iteration <= STUB_SHRINK_ITER
12707                 || group->stub_sec->rawsize < group->stub_sec->size))
12708           break;
12709
12710       if (group == NULL
12711           && (htab->glink_eh_frame == NULL
12712               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12713         break;
12714
12715       /* Ask the linker to do its stuff.  */
12716       (*htab->params->layout_sections_again) ();
12717     }
12718
12719   if (htab->glink_eh_frame != NULL
12720       && htab->glink_eh_frame->size != 0)
12721     {
12722       bfd_vma val;
12723       bfd_byte *p, *last_fde;
12724       size_t last_fde_len, size, align, pad;
12725       struct map_stub *group;
12726
12727       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12728       if (p == NULL)
12729         return FALSE;
12730       htab->glink_eh_frame->contents = p;
12731       last_fde = p;
12732       align = 4;
12733
12734       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12735       /* CIE length (rewrite in case little-endian).  */
12736       last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12737       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12738       p += last_fde_len + 4;
12739
12740       for (group = htab->group; group != NULL; group = group->next)
12741         if (group->stub_sec != NULL)
12742           {
12743             last_fde = p;
12744             last_fde_len = stub_eh_frame_size (group, align) - 4;
12745             /* FDE length.  */
12746             bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12747             p += 4;
12748             /* CIE pointer.  */
12749             val = p - htab->glink_eh_frame->contents;
12750             bfd_put_32 (htab->elf.dynobj, val, p);
12751             p += 4;
12752             /* Offset to stub section, written later.  */
12753             p += 4;
12754             /* stub section size.  */
12755             bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12756             p += 4;
12757             /* Augmentation.  */
12758             p += 1;
12759             if (group->tls_get_addr_opt_bctrl != -1u)
12760               {
12761                 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12762
12763                 /* This FDE needs more than just the default.
12764                    Describe __tls_get_addr_opt stub LR.  */
12765                 if (to_bctrl < 64)
12766                   *p++ = DW_CFA_advance_loc + to_bctrl;
12767                 else if (to_bctrl < 256)
12768                   {
12769                     *p++ = DW_CFA_advance_loc1;
12770                     *p++ = to_bctrl;
12771                   }
12772                 else if (to_bctrl < 65536)
12773                   {
12774                     *p++ = DW_CFA_advance_loc2;
12775                     bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12776                     p += 2;
12777                   }
12778                 else
12779                   {
12780                     *p++ = DW_CFA_advance_loc4;
12781                     bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12782                     p += 4;
12783                   }
12784                 *p++ = DW_CFA_offset_extended_sf;
12785                 *p++ = 65;
12786                 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12787                 *p++ = DW_CFA_advance_loc + 4;
12788                 *p++ = DW_CFA_restore_extended;
12789                 *p++ = 65;
12790               }
12791             /* Pad.  */
12792             p = last_fde + last_fde_len + 4;
12793           }
12794       if (htab->glink != NULL && htab->glink->size != 0)
12795         {
12796           last_fde = p;
12797           last_fde_len = ((24 + align - 1) & -align) - 4;
12798           /* FDE length.  */
12799           bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12800           p += 4;
12801           /* CIE pointer.  */
12802           val = p - htab->glink_eh_frame->contents;
12803           bfd_put_32 (htab->elf.dynobj, val, p);
12804           p += 4;
12805           /* Offset to .glink, written later.  */
12806           p += 4;
12807           /* .glink size.  */
12808           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12809           p += 4;
12810           /* Augmentation.  */
12811           p += 1;
12812
12813           *p++ = DW_CFA_advance_loc + 1;
12814           *p++ = DW_CFA_register;
12815           *p++ = 65;
12816           *p++ = htab->opd_abi ? 12 : 0;
12817           *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12818           *p++ = DW_CFA_restore_extended;
12819           *p++ = 65;
12820           p += ((24 + align - 1) & -align) - 24;
12821         }
12822       /* Subsume any padding into the last FDE if user .eh_frame
12823          sections are aligned more than glink_eh_frame.  Otherwise any
12824          zero padding will be seen as a terminator.  */
12825       align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12826       size = p - htab->glink_eh_frame->contents;
12827       pad = ((size + align - 1) & -align) - size;
12828       htab->glink_eh_frame->size = size + pad;
12829       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12830     }
12831
12832   maybe_strip_output (info, htab->brlt);
12833   if (htab->glink_eh_frame != NULL)
12834     maybe_strip_output (info, htab->glink_eh_frame);
12835
12836   return TRUE;
12837 }
12838
12839 /* Called after we have determined section placement.  If sections
12840    move, we'll be called again.  Provide a value for TOCstart.  */
12841
12842 bfd_vma
12843 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12844 {
12845   asection *s;
12846   bfd_vma TOCstart, adjust;
12847
12848   if (info != NULL)
12849     {
12850       struct elf_link_hash_entry *h;
12851       struct elf_link_hash_table *htab = elf_hash_table (info);
12852
12853       if (is_elf_hash_table (htab)
12854           && htab->hgot != NULL)
12855         h = htab->hgot;
12856       else
12857         {
12858           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12859           if (is_elf_hash_table (htab))
12860             htab->hgot = h;
12861         }
12862       if (h != NULL
12863           && h->root.type == bfd_link_hash_defined
12864           && !h->root.linker_def
12865           && (!is_elf_hash_table (htab)
12866               || h->def_regular))
12867         {
12868           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12869                       + h->root.u.def.section->output_offset
12870                       + h->root.u.def.section->output_section->vma);
12871           _bfd_set_gp_value (obfd, TOCstart);
12872           return TOCstart;
12873         }
12874     }
12875
12876   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12877      order.  The TOC starts where the first of these sections starts.  */
12878   s = bfd_get_section_by_name (obfd, ".got");
12879   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12880     s = bfd_get_section_by_name (obfd, ".toc");
12881   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12882     s = bfd_get_section_by_name (obfd, ".tocbss");
12883   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12884     s = bfd_get_section_by_name (obfd, ".plt");
12885   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12886     {
12887       /* This may happen for
12888          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12889          .toc directive
12890          o  bad linker script
12891          o --gc-sections and empty TOC sections
12892
12893          FIXME: Warn user?  */
12894
12895       /* Look for a likely section.  We probably won't even be
12896          using TOCstart.  */
12897       for (s = obfd->sections; s != NULL; s = s->next)
12898         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12899                          | SEC_EXCLUDE))
12900             == (SEC_ALLOC | SEC_SMALL_DATA))
12901           break;
12902       if (s == NULL)
12903         for (s = obfd->sections; s != NULL; s = s->next)
12904           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12905               == (SEC_ALLOC | SEC_SMALL_DATA))
12906             break;
12907       if (s == NULL)
12908         for (s = obfd->sections; s != NULL; s = s->next)
12909           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12910               == SEC_ALLOC)
12911             break;
12912       if (s == NULL)
12913         for (s = obfd->sections; s != NULL; s = s->next)
12914           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12915             break;
12916     }
12917
12918   TOCstart = 0;
12919   if (s != NULL)
12920     TOCstart = s->output_section->vma + s->output_offset;
12921
12922   /* Force alignment.  */
12923   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12924   TOCstart -= adjust;
12925   _bfd_set_gp_value (obfd, TOCstart);
12926
12927   if (info != NULL && s != NULL)
12928     {
12929       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12930
12931       if (htab != NULL)
12932         {
12933           if (htab->elf.hgot != NULL)
12934             {
12935               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12936               htab->elf.hgot->root.u.def.section = s;
12937             }
12938         }
12939       else
12940         {
12941           struct bfd_link_hash_entry *bh = NULL;
12942           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12943                                             s, TOC_BASE_OFF - adjust,
12944                                             NULL, FALSE, FALSE, &bh);
12945         }
12946     }
12947   return TOCstart;
12948 }
12949
12950 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12951    write out any global entry stubs.  */
12952
12953 static bfd_boolean
12954 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12955 {
12956   struct bfd_link_info *info;
12957   struct ppc_link_hash_table *htab;
12958   struct plt_entry *pent;
12959   asection *s;
12960
12961   if (h->root.type == bfd_link_hash_indirect)
12962     return TRUE;
12963
12964   if (!h->pointer_equality_needed)
12965     return TRUE;
12966
12967   if (h->def_regular)
12968     return TRUE;
12969
12970   info = inf;
12971   htab = ppc_hash_table (info);
12972   if (htab == NULL)
12973     return FALSE;
12974
12975   s = htab->glink;
12976   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12977     if (pent->plt.offset != (bfd_vma) -1
12978         && pent->addend == 0)
12979       {
12980         bfd_byte *p;
12981         asection *plt;
12982         bfd_vma off;
12983
12984         p = s->contents + h->root.u.def.value;
12985         plt = htab->elf.splt;
12986         if (!htab->elf.dynamic_sections_created
12987             || h->dynindx == -1)
12988           plt = htab->elf.iplt;
12989         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12990         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12991
12992         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12993           {
12994             info->callbacks->einfo
12995               (_("%P: linkage table error against `%T'\n"),
12996                h->root.root.string);
12997             bfd_set_error (bfd_error_bad_value);
12998             htab->stub_error = TRUE;
12999           }
13000
13001         htab->stub_count[ppc_stub_global_entry - 1] += 1;
13002         if (htab->params->emit_stub_syms)
13003           {
13004             size_t len = strlen (h->root.root.string);
13005             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13006
13007             if (name == NULL)
13008               return FALSE;
13009
13010             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13011             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13012             if (h == NULL)
13013               return FALSE;
13014             if (h->root.type == bfd_link_hash_new)
13015               {
13016                 h->root.type = bfd_link_hash_defined;
13017                 h->root.u.def.section = s;
13018                 h->root.u.def.value = p - s->contents;
13019                 h->ref_regular = 1;
13020                 h->def_regular = 1;
13021                 h->ref_regular_nonweak = 1;
13022                 h->forced_local = 1;
13023                 h->non_elf = 0;
13024                 h->root.linker_def = 1;
13025               }
13026           }
13027
13028         if (PPC_HA (off) != 0)
13029           {
13030             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13031             p += 4;
13032           }
13033         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13034         p += 4;
13035         bfd_put_32 (s->owner, MTCTR_R12, p);
13036         p += 4;
13037         bfd_put_32 (s->owner, BCTR, p);
13038         break;
13039       }
13040   return TRUE;
13041 }
13042
13043 /* Build all the stubs associated with the current output file.
13044    The stubs are kept in a hash table attached to the main linker
13045    hash table.  This function is called via gldelf64ppc_finish.  */
13046
13047 bfd_boolean
13048 ppc64_elf_build_stubs (struct bfd_link_info *info,
13049                        char **stats)
13050 {
13051   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13052   struct map_stub *group;
13053   asection *stub_sec;
13054   bfd_byte *p;
13055   int stub_sec_count = 0;
13056
13057   if (htab == NULL)
13058     return FALSE;
13059
13060   /* Allocate memory to hold the linker stubs.  */
13061   for (group = htab->group; group != NULL; group = group->next)
13062     if ((stub_sec = group->stub_sec) != NULL
13063         && stub_sec->size != 0)
13064       {
13065         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13066         if (stub_sec->contents == NULL)
13067           return FALSE;
13068         stub_sec->size = 0;
13069       }
13070
13071   if (htab->glink != NULL && htab->glink->size != 0)
13072     {
13073       unsigned int indx;
13074       bfd_vma plt0;
13075
13076       /* Build the .glink plt call stub.  */
13077       if (htab->params->emit_stub_syms)
13078         {
13079           struct elf_link_hash_entry *h;
13080           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13081                                     TRUE, FALSE, FALSE);
13082           if (h == NULL)
13083             return FALSE;
13084           if (h->root.type == bfd_link_hash_new)
13085             {
13086               h->root.type = bfd_link_hash_defined;
13087               h->root.u.def.section = htab->glink;
13088               h->root.u.def.value = 8;
13089               h->ref_regular = 1;
13090               h->def_regular = 1;
13091               h->ref_regular_nonweak = 1;
13092               h->forced_local = 1;
13093               h->non_elf = 0;
13094               h->root.linker_def = 1;
13095             }
13096         }
13097       plt0 = (htab->elf.splt->output_section->vma
13098               + htab->elf.splt->output_offset
13099               - 16);
13100       if (info->emitrelocations)
13101         {
13102           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13103           if (r == NULL)
13104             return FALSE;
13105           r->r_offset = (htab->glink->output_offset
13106                          + htab->glink->output_section->vma);
13107           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13108           r->r_addend = plt0;
13109         }
13110       p = htab->glink->contents;
13111       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13112       bfd_put_64 (htab->glink->owner, plt0, p);
13113       p += 8;
13114       if (htab->opd_abi)
13115         {
13116           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13117           p += 4;
13118           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13119           p += 4;
13120           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13121           p += 4;
13122           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13123           p += 4;
13124           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13125           p += 4;
13126           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13127           p += 4;
13128           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13129           p += 4;
13130           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13131           p += 4;
13132           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13133           p += 4;
13134           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13135           p += 4;
13136         }
13137       else
13138         {
13139           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13140           p += 4;
13141           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13142           p += 4;
13143           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13144           p += 4;
13145           bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13146           p += 4;
13147           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13148           p += 4;
13149           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13150           p += 4;
13151           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13152           p += 4;
13153           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13154           p += 4;
13155           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13156           p += 4;
13157           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13158           p += 4;
13159           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13160           p += 4;
13161           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13162           p += 4;
13163           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13164           p += 4;
13165         }
13166       bfd_put_32 (htab->glink->owner, BCTR, p);
13167       p += 4;
13168       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13169         {
13170           bfd_put_32 (htab->glink->owner, NOP, p);
13171           p += 4;
13172         }
13173
13174       /* Build the .glink lazy link call stubs.  */
13175       indx = 0;
13176       while (p < htab->glink->contents + htab->glink->rawsize)
13177         {
13178           if (htab->opd_abi)
13179             {
13180               if (indx < 0x8000)
13181                 {
13182                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13183                   p += 4;
13184                 }
13185               else
13186                 {
13187                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13188                   p += 4;
13189                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13190                               p);
13191                   p += 4;
13192                 }
13193             }
13194           bfd_put_32 (htab->glink->owner,
13195                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13196           indx++;
13197           p += 4;
13198         }
13199
13200       /* Build .glink global entry stubs.  */
13201       if (htab->glink->size > htab->glink->rawsize)
13202         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13203     }
13204
13205   if (htab->brlt != NULL && htab->brlt->size != 0)
13206     {
13207       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13208                                          htab->brlt->size);
13209       if (htab->brlt->contents == NULL)
13210         return FALSE;
13211     }
13212   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13213     {
13214       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13215                                             htab->relbrlt->size);
13216       if (htab->relbrlt->contents == NULL)
13217         return FALSE;
13218     }
13219
13220   /* Build the stubs as directed by the stub hash table.  */
13221   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13222
13223   for (group = htab->group; group != NULL; group = group->next)
13224     if (group->needs_save_res)
13225       {
13226         stub_sec = group->stub_sec;
13227         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13228                 htab->sfpr->size);
13229         if (htab->params->emit_stub_syms)
13230           {
13231             unsigned int i;
13232
13233             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13234               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13235                 return FALSE;
13236           }
13237         stub_sec->size += htab->sfpr->size;
13238       }
13239
13240   if (htab->relbrlt != NULL)
13241     htab->relbrlt->reloc_count = 0;
13242
13243   if (htab->params->plt_stub_align != 0)
13244     for (group = htab->group; group != NULL; group = group->next)
13245       if ((stub_sec = group->stub_sec) != NULL)
13246         stub_sec->size = ((stub_sec->size
13247                            + (1 << htab->params->plt_stub_align) - 1)
13248                           & -(1 << htab->params->plt_stub_align));
13249
13250   for (group = htab->group; group != NULL; group = group->next)
13251     if ((stub_sec = group->stub_sec) != NULL)
13252       {
13253         stub_sec_count += 1;
13254         if (stub_sec->rawsize != stub_sec->size
13255             && (htab->stub_iteration <= STUB_SHRINK_ITER
13256                 || stub_sec->rawsize < stub_sec->size))
13257           break;
13258       }
13259
13260   if (group != NULL)
13261     {
13262       htab->stub_error = TRUE;
13263       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13264     }
13265
13266   if (htab->stub_error)
13267     return FALSE;
13268
13269   if (stats != NULL)
13270     {
13271       *stats = bfd_malloc (500);
13272       if (*stats == NULL)
13273         return FALSE;
13274
13275       sprintf (*stats, _("linker stubs in %u group%s\n"
13276                          "  branch       %lu\n"
13277                          "  toc adjust   %lu\n"
13278                          "  long branch  %lu\n"
13279                          "  long toc adj %lu\n"
13280                          "  plt call     %lu\n"
13281                          "  plt call toc %lu\n"
13282                          "  global entry %lu"),
13283                stub_sec_count,
13284                stub_sec_count == 1 ? "" : "s",
13285                htab->stub_count[ppc_stub_long_branch - 1],
13286                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13287                htab->stub_count[ppc_stub_plt_branch - 1],
13288                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13289                htab->stub_count[ppc_stub_plt_call - 1],
13290                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13291                htab->stub_count[ppc_stub_global_entry - 1]);
13292     }
13293   return TRUE;
13294 }
13295
13296 /* What to do when ld finds relocations against symbols defined in
13297    discarded sections.  */
13298
13299 static unsigned int
13300 ppc64_elf_action_discarded (asection *sec)
13301 {
13302   if (strcmp (".opd", sec->name) == 0)
13303     return 0;
13304
13305   if (strcmp (".toc", sec->name) == 0)
13306     return 0;
13307
13308   if (strcmp (".toc1", sec->name) == 0)
13309     return 0;
13310
13311   return _bfd_elf_default_action_discarded (sec);
13312 }
13313
13314 /* The RELOCATE_SECTION function is called by the ELF backend linker
13315    to handle the relocations for a section.
13316
13317    The relocs are always passed as Rela structures; if the section
13318    actually uses Rel structures, the r_addend field will always be
13319    zero.
13320
13321    This function is responsible for adjust the section contents as
13322    necessary, and (if using Rela relocs and generating a
13323    relocatable output file) adjusting the reloc addend as
13324    necessary.
13325
13326    This function does not have to worry about setting the reloc
13327    address or the reloc symbol index.
13328
13329    LOCAL_SYMS is a pointer to the swapped in local symbols.
13330
13331    LOCAL_SECTIONS is an array giving the section in the input file
13332    corresponding to the st_shndx field of each local symbol.
13333
13334    The global hash table entry for the global symbols can be found
13335    via elf_sym_hashes (input_bfd).
13336
13337    When generating relocatable output, this function must handle
13338    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13339    going to be the section symbol corresponding to the output
13340    section, which means that the addend must be adjusted
13341    accordingly.  */
13342
13343 static bfd_boolean
13344 ppc64_elf_relocate_section (bfd *output_bfd,
13345                             struct bfd_link_info *info,
13346                             bfd *input_bfd,
13347                             asection *input_section,
13348                             bfd_byte *contents,
13349                             Elf_Internal_Rela *relocs,
13350                             Elf_Internal_Sym *local_syms,
13351                             asection **local_sections)
13352 {
13353   struct ppc_link_hash_table *htab;
13354   Elf_Internal_Shdr *symtab_hdr;
13355   struct elf_link_hash_entry **sym_hashes;
13356   Elf_Internal_Rela *rel;
13357   Elf_Internal_Rela *wrel;
13358   Elf_Internal_Rela *relend;
13359   Elf_Internal_Rela outrel;
13360   bfd_byte *loc;
13361   struct got_entry **local_got_ents;
13362   bfd_vma TOCstart;
13363   bfd_boolean ret = TRUE;
13364   bfd_boolean is_opd;
13365   /* Assume 'at' branch hints.  */
13366   bfd_boolean is_isa_v2 = TRUE;
13367   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13368
13369   /* Initialize howto table if needed.  */
13370   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13371     ppc_howto_init ();
13372
13373   htab = ppc_hash_table (info);
13374   if (htab == NULL)
13375     return FALSE;
13376
13377   /* Don't relocate stub sections.  */
13378   if (input_section->owner == htab->params->stub_bfd)
13379     return TRUE;
13380
13381   BFD_ASSERT (is_ppc64_elf (input_bfd));
13382
13383   local_got_ents = elf_local_got_ents (input_bfd);
13384   TOCstart = elf_gp (output_bfd);
13385   symtab_hdr = &elf_symtab_hdr (input_bfd);
13386   sym_hashes = elf_sym_hashes (input_bfd);
13387   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13388
13389   rel = wrel = relocs;
13390   relend = relocs + input_section->reloc_count;
13391   for (; rel < relend; wrel++, rel++)
13392     {
13393       enum elf_ppc64_reloc_type r_type;
13394       bfd_vma addend;
13395       bfd_reloc_status_type r;
13396       Elf_Internal_Sym *sym;
13397       asection *sec;
13398       struct elf_link_hash_entry *h_elf;
13399       struct ppc_link_hash_entry *h;
13400       struct ppc_link_hash_entry *fdh;
13401       const char *sym_name;
13402       unsigned long r_symndx, toc_symndx;
13403       bfd_vma toc_addend;
13404       unsigned char tls_mask, tls_gd, tls_type;
13405       unsigned char sym_type;
13406       bfd_vma relocation;
13407       bfd_boolean unresolved_reloc;
13408       bfd_boolean warned;
13409       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13410       unsigned int insn;
13411       unsigned int mask;
13412       struct ppc_stub_hash_entry *stub_entry;
13413       bfd_vma max_br_offset;
13414       bfd_vma from;
13415       Elf_Internal_Rela orig_rel;
13416       reloc_howto_type *howto;
13417       struct reloc_howto_struct alt_howto;
13418
13419     again:
13420       orig_rel = *rel;
13421
13422       r_type = ELF64_R_TYPE (rel->r_info);
13423       r_symndx = ELF64_R_SYM (rel->r_info);
13424
13425       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13426          symbol of the previous ADDR64 reloc.  The symbol gives us the
13427          proper TOC base to use.  */
13428       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13429           && wrel != relocs
13430           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13431           && is_opd)
13432         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13433
13434       sym = NULL;
13435       sec = NULL;
13436       h_elf = NULL;
13437       sym_name = NULL;
13438       unresolved_reloc = FALSE;
13439       warned = FALSE;
13440
13441       if (r_symndx < symtab_hdr->sh_info)
13442         {
13443           /* It's a local symbol.  */
13444           struct _opd_sec_data *opd;
13445
13446           sym = local_syms + r_symndx;
13447           sec = local_sections[r_symndx];
13448           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13449           sym_type = ELF64_ST_TYPE (sym->st_info);
13450           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13451           opd = get_opd_info (sec);
13452           if (opd != NULL && opd->adjust != NULL)
13453             {
13454               long adjust = opd->adjust[OPD_NDX (sym->st_value
13455                                                  + rel->r_addend)];
13456               if (adjust == -1)
13457                 relocation = 0;
13458               else
13459                 {
13460                   /* If this is a relocation against the opd section sym
13461                      and we have edited .opd, adjust the reloc addend so
13462                      that ld -r and ld --emit-relocs output is correct.
13463                      If it is a reloc against some other .opd symbol,
13464                      then the symbol value will be adjusted later.  */
13465                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13466                     rel->r_addend += adjust;
13467                   else
13468                     relocation += adjust;
13469                 }
13470             }
13471         }
13472       else
13473         {
13474           bfd_boolean ignored;
13475
13476           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13477                                    r_symndx, symtab_hdr, sym_hashes,
13478                                    h_elf, sec, relocation,
13479                                    unresolved_reloc, warned, ignored);
13480           sym_name = h_elf->root.root.string;
13481           sym_type = h_elf->type;
13482           if (sec != NULL
13483               && sec->owner == output_bfd
13484               && strcmp (sec->name, ".opd") == 0)
13485             {
13486               /* This is a symbol defined in a linker script.  All
13487                  such are defined in output sections, even those
13488                  defined by simple assignment from a symbol defined in
13489                  an input section.  Transfer the symbol to an
13490                  appropriate input .opd section, so that a branch to
13491                  this symbol will be mapped to the location specified
13492                  by the opd entry.  */
13493               struct bfd_link_order *lo;
13494               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13495                 if (lo->type == bfd_indirect_link_order)
13496                   {
13497                     asection *isec = lo->u.indirect.section;
13498                     if (h_elf->root.u.def.value >= isec->output_offset
13499                         && h_elf->root.u.def.value < (isec->output_offset
13500                                                       + isec->size))
13501                       {
13502                         h_elf->root.u.def.value -= isec->output_offset;
13503                         h_elf->root.u.def.section = isec;
13504                         sec = isec;
13505                         break;
13506                       }
13507                   }
13508             }
13509         }
13510       h = (struct ppc_link_hash_entry *) h_elf;
13511
13512       if (sec != NULL && discarded_section (sec))
13513         {
13514           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13515                                input_bfd, input_section,
13516                                contents + rel->r_offset);
13517           wrel->r_offset = rel->r_offset;
13518           wrel->r_info = 0;
13519           wrel->r_addend = 0;
13520
13521           /* For ld -r, remove relocations in debug sections against
13522              symbols defined in discarded sections.  Not done for
13523              non-debug to preserve relocs in .eh_frame which the
13524              eh_frame editing code expects to be present.  */
13525           if (bfd_link_relocatable (info)
13526               && (input_section->flags & SEC_DEBUGGING))
13527             wrel--;
13528
13529           continue;
13530         }
13531
13532       if (bfd_link_relocatable (info))
13533         goto copy_reloc;
13534
13535       if (h != NULL && &h->elf == htab->elf.hgot)
13536         {
13537           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13538           sec = bfd_abs_section_ptr;
13539           unresolved_reloc = FALSE;
13540         }
13541
13542       /* TLS optimizations.  Replace instruction sequences and relocs
13543          based on information we collected in tls_optimize.  We edit
13544          RELOCS so that --emit-relocs will output something sensible
13545          for the final instruction stream.  */
13546       tls_mask = 0;
13547       tls_gd = 0;
13548       toc_symndx = 0;
13549       if (h != NULL)
13550         tls_mask = h->tls_mask;
13551       else if (local_got_ents != NULL)
13552         {
13553           struct plt_entry **local_plt = (struct plt_entry **)
13554             (local_got_ents + symtab_hdr->sh_info);
13555           unsigned char *lgot_masks = (unsigned char *)
13556             (local_plt + symtab_hdr->sh_info);
13557           tls_mask = lgot_masks[r_symndx];
13558         }
13559       if (tls_mask == 0
13560           && (r_type == R_PPC64_TLS
13561               || r_type == R_PPC64_TLSGD
13562               || r_type == R_PPC64_TLSLD))
13563         {
13564           /* Check for toc tls entries.  */
13565           unsigned char *toc_tls;
13566
13567           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13568                              &local_syms, rel, input_bfd))
13569             return FALSE;
13570
13571           if (toc_tls)
13572             tls_mask = *toc_tls;
13573         }
13574
13575       /* Check that tls relocs are used with tls syms, and non-tls
13576          relocs are used with non-tls syms.  */
13577       if (r_symndx != STN_UNDEF
13578           && r_type != R_PPC64_NONE
13579           && (h == NULL
13580               || h->elf.root.type == bfd_link_hash_defined
13581               || h->elf.root.type == bfd_link_hash_defweak)
13582           && (IS_PPC64_TLS_RELOC (r_type)
13583               != (sym_type == STT_TLS
13584                   || (sym_type == STT_SECTION
13585                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13586         {
13587           if (tls_mask != 0
13588               && (r_type == R_PPC64_TLS
13589                   || r_type == R_PPC64_TLSGD
13590                   || r_type == R_PPC64_TLSLD))
13591             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13592             ;
13593           else
13594             info->callbacks->einfo
13595               (!IS_PPC64_TLS_RELOC (r_type)
13596                /* xgettext:c-format */
13597                ? _("%H: %s used with TLS symbol `%T'\n")
13598                /* xgettext:c-format */
13599                : _("%H: %s used with non-TLS symbol `%T'\n"),
13600                input_bfd, input_section, rel->r_offset,
13601                ppc64_elf_howto_table[r_type]->name,
13602                sym_name);
13603         }
13604
13605       /* Ensure reloc mapping code below stays sane.  */
13606       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13607           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13608           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13609           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13610           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13611           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13612           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13613           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13614           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13615           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13616         abort ();
13617
13618       switch (r_type)
13619         {
13620         default:
13621           break;
13622
13623         case R_PPC64_LO_DS_OPT:
13624           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13625           if ((insn & (0x3f << 26)) != 58u << 26)
13626             abort ();
13627           insn += (14u << 26) - (58u << 26);
13628           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13629           r_type = R_PPC64_TOC16_LO;
13630           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13631           break;
13632
13633         case R_PPC64_TOC16:
13634         case R_PPC64_TOC16_LO:
13635         case R_PPC64_TOC16_DS:
13636         case R_PPC64_TOC16_LO_DS:
13637           {
13638             /* Check for toc tls entries.  */
13639             unsigned char *toc_tls;
13640             int retval;
13641
13642             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13643                                    &local_syms, rel, input_bfd);
13644             if (retval == 0)
13645               return FALSE;
13646
13647             if (toc_tls)
13648               {
13649                 tls_mask = *toc_tls;
13650                 if (r_type == R_PPC64_TOC16_DS
13651                     || r_type == R_PPC64_TOC16_LO_DS)
13652                   {
13653                     if (tls_mask != 0
13654                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13655                       goto toctprel;
13656                   }
13657                 else
13658                   {
13659                     /* If we found a GD reloc pair, then we might be
13660                        doing a GD->IE transition.  */
13661                     if (retval == 2)
13662                       {
13663                         tls_gd = TLS_TPRELGD;
13664                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13665                           goto tls_ldgd_opt;
13666                       }
13667                     else if (retval == 3)
13668                       {
13669                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13670                           goto tls_ldgd_opt;
13671                       }
13672                   }
13673               }
13674           }
13675           break;
13676
13677         case R_PPC64_GOT_TPREL16_HI:
13678         case R_PPC64_GOT_TPREL16_HA:
13679           if (tls_mask != 0
13680               && (tls_mask & TLS_TPREL) == 0)
13681             {
13682               rel->r_offset -= d_offset;
13683               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13684               r_type = R_PPC64_NONE;
13685               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13686             }
13687           break;
13688
13689         case R_PPC64_GOT_TPREL16_DS:
13690         case R_PPC64_GOT_TPREL16_LO_DS:
13691           if (tls_mask != 0
13692               && (tls_mask & TLS_TPREL) == 0)
13693             {
13694             toctprel:
13695               insn = bfd_get_32 (input_bfd,
13696                                  contents + rel->r_offset - d_offset);
13697               insn &= 31 << 21;
13698               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13699               bfd_put_32 (input_bfd, insn,
13700                           contents + rel->r_offset - d_offset);
13701               r_type = R_PPC64_TPREL16_HA;
13702               if (toc_symndx != 0)
13703                 {
13704                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13705                   rel->r_addend = toc_addend;
13706                   /* We changed the symbol.  Start over in order to
13707                      get h, sym, sec etc. right.  */
13708                   goto again;
13709                 }
13710               else
13711                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13712             }
13713           break;
13714
13715         case R_PPC64_TLS:
13716           if (tls_mask != 0
13717               && (tls_mask & TLS_TPREL) == 0)
13718             {
13719               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13720               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13721               if (insn == 0)
13722                 abort ();
13723               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13724               /* Was PPC64_TLS which sits on insn boundary, now
13725                  PPC64_TPREL16_LO which is at low-order half-word.  */
13726               rel->r_offset += d_offset;
13727               r_type = R_PPC64_TPREL16_LO;
13728               if (toc_symndx != 0)
13729                 {
13730                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13731                   rel->r_addend = toc_addend;
13732                   /* We changed the symbol.  Start over in order to
13733                      get h, sym, sec etc. right.  */
13734                   goto again;
13735                 }
13736               else
13737                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13738             }
13739           break;
13740
13741         case R_PPC64_GOT_TLSGD16_HI:
13742         case R_PPC64_GOT_TLSGD16_HA:
13743           tls_gd = TLS_TPRELGD;
13744           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13745             goto tls_gdld_hi;
13746           break;
13747
13748         case R_PPC64_GOT_TLSLD16_HI:
13749         case R_PPC64_GOT_TLSLD16_HA:
13750           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13751             {
13752             tls_gdld_hi:
13753               if ((tls_mask & tls_gd) != 0)
13754                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13755                           + R_PPC64_GOT_TPREL16_DS);
13756               else
13757                 {
13758                   rel->r_offset -= d_offset;
13759                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13760                   r_type = R_PPC64_NONE;
13761                 }
13762               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13763             }
13764           break;
13765
13766         case R_PPC64_GOT_TLSGD16:
13767         case R_PPC64_GOT_TLSGD16_LO:
13768           tls_gd = TLS_TPRELGD;
13769           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13770             goto tls_ldgd_opt;
13771           break;
13772
13773         case R_PPC64_GOT_TLSLD16:
13774         case R_PPC64_GOT_TLSLD16_LO:
13775           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13776             {
13777               unsigned int insn1, insn2;
13778               bfd_vma offset;
13779
13780             tls_ldgd_opt:
13781               offset = (bfd_vma) -1;
13782               /* If not using the newer R_PPC64_TLSGD/LD to mark
13783                  __tls_get_addr calls, we must trust that the call
13784                  stays with its arg setup insns, ie. that the next
13785                  reloc is the __tls_get_addr call associated with
13786                  the current reloc.  Edit both insns.  */
13787               if (input_section->has_tls_get_addr_call
13788                   && rel + 1 < relend
13789                   && branch_reloc_hash_match (input_bfd, rel + 1,
13790                                               htab->tls_get_addr,
13791                                               htab->tls_get_addr_fd))
13792                 offset = rel[1].r_offset;
13793               /* We read the low GOT_TLS (or TOC16) insn because we
13794                  need to keep the destination reg.  It may be
13795                  something other than the usual r3, and moved to r3
13796                  before the call by intervening code.  */
13797               insn1 = bfd_get_32 (input_bfd,
13798                                   contents + rel->r_offset - d_offset);
13799               if ((tls_mask & tls_gd) != 0)
13800                 {
13801                   /* IE */
13802                   insn1 &= (0x1f << 21) | (0x1f << 16);
13803                   insn1 |= 58 << 26;    /* ld */
13804                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13805                   if (offset != (bfd_vma) -1)
13806                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13807                   if ((tls_mask & TLS_EXPLICIT) == 0)
13808                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13809                               + R_PPC64_GOT_TPREL16_DS);
13810                   else
13811                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13812                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13813                 }
13814               else
13815                 {
13816                   /* LE */
13817                   insn1 &= 0x1f << 21;
13818                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13819                   insn2 = 0x38630000;   /* addi 3,3,0 */
13820                   if (tls_gd == 0)
13821                     {
13822                       /* Was an LD reloc.  */
13823                       if (toc_symndx)
13824                         sec = local_sections[toc_symndx];
13825                       for (r_symndx = 0;
13826                            r_symndx < symtab_hdr->sh_info;
13827                            r_symndx++)
13828                         if (local_sections[r_symndx] == sec)
13829                           break;
13830                       if (r_symndx >= symtab_hdr->sh_info)
13831                         r_symndx = STN_UNDEF;
13832                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13833                       if (r_symndx != STN_UNDEF)
13834                         rel->r_addend -= (local_syms[r_symndx].st_value
13835                                           + sec->output_offset
13836                                           + sec->output_section->vma);
13837                     }
13838                   else if (toc_symndx != 0)
13839                     {
13840                       r_symndx = toc_symndx;
13841                       rel->r_addend = toc_addend;
13842                     }
13843                   r_type = R_PPC64_TPREL16_HA;
13844                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13845                   if (offset != (bfd_vma) -1)
13846                     {
13847                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13848                                                     R_PPC64_TPREL16_LO);
13849                       rel[1].r_offset = offset + d_offset;
13850                       rel[1].r_addend = rel->r_addend;
13851                     }
13852                 }
13853               bfd_put_32 (input_bfd, insn1,
13854                           contents + rel->r_offset - d_offset);
13855               if (offset != (bfd_vma) -1)
13856                 bfd_put_32 (input_bfd, insn2, contents + offset);
13857               if ((tls_mask & tls_gd) == 0
13858                   && (tls_gd == 0 || toc_symndx != 0))
13859                 {
13860                   /* We changed the symbol.  Start over in order
13861                      to get h, sym, sec etc. right.  */
13862                   goto again;
13863                 }
13864             }
13865           break;
13866
13867         case R_PPC64_TLSGD:
13868           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13869             {
13870               unsigned int insn2;
13871               bfd_vma offset = rel->r_offset;
13872
13873               if ((tls_mask & TLS_TPRELGD) != 0)
13874                 {
13875                   /* IE */
13876                   r_type = R_PPC64_NONE;
13877                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13878                 }
13879               else
13880                 {
13881                   /* LE */
13882                   if (toc_symndx != 0)
13883                     {
13884                       r_symndx = toc_symndx;
13885                       rel->r_addend = toc_addend;
13886                     }
13887                   r_type = R_PPC64_TPREL16_LO;
13888                   rel->r_offset = offset + d_offset;
13889                   insn2 = 0x38630000;   /* addi 3,3,0 */
13890                 }
13891               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13892               /* Zap the reloc on the _tls_get_addr call too.  */
13893               BFD_ASSERT (offset == rel[1].r_offset);
13894               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13895               bfd_put_32 (input_bfd, insn2, contents + offset);
13896               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13897                 goto again;
13898             }
13899           break;
13900
13901         case R_PPC64_TLSLD:
13902           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13903             {
13904               unsigned int insn2;
13905               bfd_vma offset = rel->r_offset;
13906
13907               if (toc_symndx)
13908                 sec = local_sections[toc_symndx];
13909               for (r_symndx = 0;
13910                    r_symndx < symtab_hdr->sh_info;
13911                    r_symndx++)
13912                 if (local_sections[r_symndx] == sec)
13913                   break;
13914               if (r_symndx >= symtab_hdr->sh_info)
13915                 r_symndx = STN_UNDEF;
13916               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13917               if (r_symndx != STN_UNDEF)
13918                 rel->r_addend -= (local_syms[r_symndx].st_value
13919                                   + sec->output_offset
13920                                   + sec->output_section->vma);
13921
13922               r_type = R_PPC64_TPREL16_LO;
13923               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13924               rel->r_offset = offset + d_offset;
13925               /* Zap the reloc on the _tls_get_addr call too.  */
13926               BFD_ASSERT (offset == rel[1].r_offset);
13927               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13928               insn2 = 0x38630000;       /* addi 3,3,0 */
13929               bfd_put_32 (input_bfd, insn2, contents + offset);
13930               goto again;
13931             }
13932           break;
13933
13934         case R_PPC64_DTPMOD64:
13935           if (rel + 1 < relend
13936               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13937               && rel[1].r_offset == rel->r_offset + 8)
13938             {
13939               if ((tls_mask & TLS_GD) == 0)
13940                 {
13941                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13942                   if ((tls_mask & TLS_TPRELGD) != 0)
13943                     r_type = R_PPC64_TPREL64;
13944                   else
13945                     {
13946                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13947                       r_type = R_PPC64_NONE;
13948                     }
13949                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13950                 }
13951             }
13952           else
13953             {
13954               if ((tls_mask & TLS_LD) == 0)
13955                 {
13956                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13957                   r_type = R_PPC64_NONE;
13958                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13959                 }
13960             }
13961           break;
13962
13963         case R_PPC64_TPREL64:
13964           if ((tls_mask & TLS_TPREL) == 0)
13965             {
13966               r_type = R_PPC64_NONE;
13967               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13968             }
13969           break;
13970
13971         case R_PPC64_ENTRY:
13972           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13973           if (!bfd_link_pic (info)
13974               && !info->traditional_format
13975               && relocation + 0x80008000 <= 0xffffffff)
13976             {
13977               unsigned int insn1, insn2;
13978
13979               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13980               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13981               if ((insn1 & ~0xfffc) == LD_R2_0R12
13982                   && insn2 == ADD_R2_R2_R12)
13983                 {
13984                   bfd_put_32 (input_bfd,
13985                               LIS_R2 + PPC_HA (relocation),
13986                               contents + rel->r_offset);
13987                   bfd_put_32 (input_bfd,
13988                               ADDI_R2_R2 + PPC_LO (relocation),
13989                               contents + rel->r_offset + 4);
13990                 }
13991             }
13992           else
13993             {
13994               relocation -= (rel->r_offset
13995                              + input_section->output_offset
13996                              + input_section->output_section->vma);
13997               if (relocation + 0x80008000 <= 0xffffffff)
13998                 {
13999                   unsigned int insn1, insn2;
14000
14001                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14002                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14003                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14004                       && insn2 == ADD_R2_R2_R12)
14005                     {
14006                       bfd_put_32 (input_bfd,
14007                                   ADDIS_R2_R12 + PPC_HA (relocation),
14008                                   contents + rel->r_offset);
14009                       bfd_put_32 (input_bfd,
14010                                   ADDI_R2_R2 + PPC_LO (relocation),
14011                                   contents + rel->r_offset + 4);
14012                     }
14013                 }
14014             }
14015           break;
14016
14017         case R_PPC64_REL16_HA:
14018           /* If we are generating a non-PIC executable, edit
14019              .  0:      addis 2,12,.TOC.-0b@ha
14020              .          addi 2,2,.TOC.-0b@l
14021              used by ELFv2 global entry points to set up r2, to
14022              .          lis 2,.TOC.@ha
14023              .          addi 2,2,.TOC.@l
14024              if .TOC. is in range.  */
14025           if (!bfd_link_pic (info)
14026               && !info->traditional_format
14027               && !htab->opd_abi
14028               && rel->r_addend == d_offset
14029               && h != NULL && &h->elf == htab->elf.hgot
14030               && rel + 1 < relend
14031               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14032               && rel[1].r_offset == rel->r_offset + 4
14033               && rel[1].r_addend == rel->r_addend + 4
14034               && relocation + 0x80008000 <= 0xffffffff)
14035             {
14036               unsigned int insn1, insn2;
14037               bfd_vma offset = rel->r_offset - d_offset;
14038               insn1 = bfd_get_32 (input_bfd, contents + offset);
14039               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14040               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14041                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14042                 {
14043                   r_type = R_PPC64_ADDR16_HA;
14044                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14045                   rel->r_addend -= d_offset;
14046                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14047                   rel[1].r_addend -= d_offset + 4;
14048                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14049                 }
14050             }
14051           break;
14052         }
14053
14054       /* Handle other relocations that tweak non-addend part of insn.  */
14055       insn = 0;
14056       max_br_offset = 1 << 25;
14057       addend = rel->r_addend;
14058       reloc_dest = DEST_NORMAL;
14059       switch (r_type)
14060         {
14061         default:
14062           break;
14063
14064         case R_PPC64_TOCSAVE:
14065           if (relocation + addend == (rel->r_offset
14066                                       + input_section->output_offset
14067                                       + input_section->output_section->vma)
14068               && tocsave_find (htab, NO_INSERT,
14069                                &local_syms, rel, input_bfd))
14070             {
14071               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14072               if (insn == NOP
14073                   || insn == CROR_151515 || insn == CROR_313131)
14074                 bfd_put_32 (input_bfd,
14075                             STD_R2_0R1 + STK_TOC (htab),
14076                             contents + rel->r_offset);
14077             }
14078           break;
14079
14080           /* Branch taken prediction relocations.  */
14081         case R_PPC64_ADDR14_BRTAKEN:
14082         case R_PPC64_REL14_BRTAKEN:
14083           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14084           /* Fall through.  */
14085
14086           /* Branch not taken prediction relocations.  */
14087         case R_PPC64_ADDR14_BRNTAKEN:
14088         case R_PPC64_REL14_BRNTAKEN:
14089           insn |= bfd_get_32 (input_bfd,
14090                               contents + rel->r_offset) & ~(0x01 << 21);
14091           /* Fall through.  */
14092
14093         case R_PPC64_REL14:
14094           max_br_offset = 1 << 15;
14095           /* Fall through.  */
14096
14097         case R_PPC64_REL24:
14098           /* Calls to functions with a different TOC, such as calls to
14099              shared objects, need to alter the TOC pointer.  This is
14100              done using a linkage stub.  A REL24 branching to these
14101              linkage stubs needs to be followed by a nop, as the nop
14102              will be replaced with an instruction to restore the TOC
14103              base pointer.  */
14104           fdh = h;
14105           if (h != NULL
14106               && h->oh != NULL
14107               && h->oh->is_func_descriptor)
14108             fdh = ppc_follow_link (h->oh);
14109           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14110                                            htab);
14111           if (stub_entry != NULL
14112               && (stub_entry->stub_type == ppc_stub_plt_call
14113                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14114                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14115                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14116             {
14117               bfd_boolean can_plt_call = FALSE;
14118
14119               if (stub_entry->stub_type == ppc_stub_plt_call
14120                   && !htab->opd_abi
14121                   && htab->params->plt_localentry0 != 0
14122                   && is_elfv2_localentry0 (&h->elf))
14123                 {
14124                   /* The function doesn't use or change r2.  */
14125                   can_plt_call = TRUE;
14126                 }
14127
14128               /* All of these stubs may modify r2, so there must be a
14129                  branch and link followed by a nop.  The nop is
14130                  replaced by an insn to restore r2.  */
14131               else if (rel->r_offset + 8 <= input_section->size)
14132                 {
14133                   unsigned long br;
14134
14135                   br = bfd_get_32 (input_bfd,
14136                                    contents + rel->r_offset);
14137                   if ((br & 1) != 0)
14138                     {
14139                       unsigned long nop;
14140
14141                       nop = bfd_get_32 (input_bfd,
14142                                         contents + rel->r_offset + 4);
14143                       if (nop == NOP
14144                           || nop == CROR_151515 || nop == CROR_313131)
14145                         {
14146                           if (h != NULL
14147                               && (h == htab->tls_get_addr_fd
14148                                   || h == htab->tls_get_addr)
14149                               && htab->params->tls_get_addr_opt)
14150                             {
14151                               /* Special stub used, leave nop alone.  */
14152                             }
14153                           else
14154                             bfd_put_32 (input_bfd,
14155                                         LD_R2_0R1 + STK_TOC (htab),
14156                                         contents + rel->r_offset + 4);
14157                           can_plt_call = TRUE;
14158                         }
14159                     }
14160                 }
14161
14162               if (!can_plt_call && h != NULL)
14163                 {
14164                   const char *name = h->elf.root.root.string;
14165
14166                   if (*name == '.')
14167                     ++name;
14168
14169                   if (strncmp (name, "__libc_start_main", 17) == 0
14170                       && (name[17] == 0 || name[17] == '@'))
14171                     {
14172                       /* Allow crt1 branch to go via a toc adjusting
14173                          stub.  Other calls that never return could do
14174                          the same, if we could detect such.  */
14175                       can_plt_call = TRUE;
14176                     }
14177                 }
14178
14179               if (!can_plt_call)
14180                 {
14181                   /* g++ as of 20130507 emits self-calls without a
14182                      following nop.  This is arguably wrong since we
14183                      have conflicting information.  On the one hand a
14184                      global symbol and on the other a local call
14185                      sequence, but don't error for this special case.
14186                      It isn't possible to cheaply verify we have
14187                      exactly such a call.  Allow all calls to the same
14188                      section.  */
14189                   asection *code_sec = sec;
14190
14191                   if (get_opd_info (sec) != NULL)
14192                     {
14193                       bfd_vma off = (relocation + addend
14194                                      - sec->output_section->vma
14195                                      - sec->output_offset);
14196
14197                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14198                     }
14199                   if (code_sec == input_section)
14200                     can_plt_call = TRUE;
14201                 }
14202
14203               if (!can_plt_call)
14204                 {
14205                   if (stub_entry->stub_type == ppc_stub_plt_call
14206                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14207                     info->callbacks->einfo
14208                       /* xgettext:c-format */
14209                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14210                          "recompile with -fPIC\n"),
14211                        input_bfd, input_section, rel->r_offset, sym_name);
14212                   else
14213                     info->callbacks->einfo
14214                       /* xgettext:c-format */
14215                       (_("%H: call to `%T' lacks nop, can't restore toc; "
14216                          "(-mcmodel=small toc adjust stub)\n"),
14217                        input_bfd, input_section, rel->r_offset, sym_name);
14218
14219                   bfd_set_error (bfd_error_bad_value);
14220                   ret = FALSE;
14221                 }
14222
14223               if (can_plt_call
14224                   && (stub_entry->stub_type == ppc_stub_plt_call
14225                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14226                 unresolved_reloc = FALSE;
14227             }
14228
14229           if ((stub_entry == NULL
14230                || stub_entry->stub_type == ppc_stub_long_branch
14231                || stub_entry->stub_type == ppc_stub_plt_branch)
14232               && get_opd_info (sec) != NULL)
14233             {
14234               /* The branch destination is the value of the opd entry. */
14235               bfd_vma off = (relocation + addend
14236                              - sec->output_section->vma
14237                              - sec->output_offset);
14238               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14239               if (dest != (bfd_vma) -1)
14240                 {
14241                   relocation = dest;
14242                   addend = 0;
14243                   reloc_dest = DEST_OPD;
14244                 }
14245             }
14246
14247           /* If the branch is out of reach we ought to have a long
14248              branch stub.  */
14249           from = (rel->r_offset
14250                   + input_section->output_offset
14251                   + input_section->output_section->vma);
14252
14253           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14254                                                   ? fdh->elf.other
14255                                                   : sym->st_other);
14256
14257           if (stub_entry != NULL
14258               && (stub_entry->stub_type == ppc_stub_long_branch
14259                   || stub_entry->stub_type == ppc_stub_plt_branch)
14260               && (r_type == R_PPC64_ADDR14_BRTAKEN
14261                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14262                   || (relocation + addend - from + max_br_offset
14263                       < 2 * max_br_offset)))
14264             /* Don't use the stub if this branch is in range.  */
14265             stub_entry = NULL;
14266
14267           if (stub_entry != NULL)
14268             {
14269               /* Munge up the value and addend so that we call the stub
14270                  rather than the procedure directly.  */
14271               asection *stub_sec = stub_entry->group->stub_sec;
14272
14273               if (stub_entry->stub_type == ppc_stub_save_res)
14274                 relocation += (stub_sec->output_offset
14275                                + stub_sec->output_section->vma
14276                                + stub_sec->size - htab->sfpr->size
14277                                - htab->sfpr->output_offset
14278                                - htab->sfpr->output_section->vma);
14279               else
14280                 relocation = (stub_entry->stub_offset
14281                               + stub_sec->output_offset
14282                               + stub_sec->output_section->vma);
14283               addend = 0;
14284               reloc_dest = DEST_STUB;
14285
14286               if ((stub_entry->stub_type == ppc_stub_plt_call
14287                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14288                   && (ALWAYS_EMIT_R2SAVE
14289                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14290                   && rel + 1 < relend
14291                   && rel[1].r_offset == rel->r_offset + 4
14292                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14293                 relocation += 4;
14294             }
14295
14296           if (insn != 0)
14297             {
14298               if (is_isa_v2)
14299                 {
14300                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14301                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14302                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14303                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14304                     insn |= 0x02 << 21;
14305                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14306                     insn |= 0x08 << 21;
14307                   else
14308                     break;
14309                 }
14310               else
14311                 {
14312                   /* Invert 'y' bit if not the default.  */
14313                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14314                     insn ^= 0x01 << 21;
14315                 }
14316
14317               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14318             }
14319
14320           /* NOP out calls to undefined weak functions.
14321              We can thus call a weak function without first
14322              checking whether the function is defined.  */
14323           else if (h != NULL
14324                    && h->elf.root.type == bfd_link_hash_undefweak
14325                    && h->elf.dynindx == -1
14326                    && r_type == R_PPC64_REL24
14327                    && relocation == 0
14328                    && addend == 0)
14329             {
14330               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14331               goto copy_reloc;
14332             }
14333           break;
14334         }
14335
14336       /* Set `addend'.  */
14337       tls_type = 0;
14338       switch (r_type)
14339         {
14340         default:
14341           info->callbacks->einfo
14342             /* xgettext:c-format */
14343             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14344              input_bfd, (int) r_type, sym_name);
14345
14346           bfd_set_error (bfd_error_bad_value);
14347           ret = FALSE;
14348           goto copy_reloc;
14349
14350         case R_PPC64_NONE:
14351         case R_PPC64_TLS:
14352         case R_PPC64_TLSGD:
14353         case R_PPC64_TLSLD:
14354         case R_PPC64_TOCSAVE:
14355         case R_PPC64_GNU_VTINHERIT:
14356         case R_PPC64_GNU_VTENTRY:
14357         case R_PPC64_ENTRY:
14358           goto copy_reloc;
14359
14360           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14361              address in the GOT as relocation value instead of the
14362              symbol's value itself.  Also, create a GOT entry for the
14363              symbol and put the symbol value there.  */
14364         case R_PPC64_GOT_TLSGD16:
14365         case R_PPC64_GOT_TLSGD16_LO:
14366         case R_PPC64_GOT_TLSGD16_HI:
14367         case R_PPC64_GOT_TLSGD16_HA:
14368           tls_type = TLS_TLS | TLS_GD;
14369           goto dogot;
14370
14371         case R_PPC64_GOT_TLSLD16:
14372         case R_PPC64_GOT_TLSLD16_LO:
14373         case R_PPC64_GOT_TLSLD16_HI:
14374         case R_PPC64_GOT_TLSLD16_HA:
14375           tls_type = TLS_TLS | TLS_LD;
14376           goto dogot;
14377
14378         case R_PPC64_GOT_TPREL16_DS:
14379         case R_PPC64_GOT_TPREL16_LO_DS:
14380         case R_PPC64_GOT_TPREL16_HI:
14381         case R_PPC64_GOT_TPREL16_HA:
14382           tls_type = TLS_TLS | TLS_TPREL;
14383           goto dogot;
14384
14385         case R_PPC64_GOT_DTPREL16_DS:
14386         case R_PPC64_GOT_DTPREL16_LO_DS:
14387         case R_PPC64_GOT_DTPREL16_HI:
14388         case R_PPC64_GOT_DTPREL16_HA:
14389           tls_type = TLS_TLS | TLS_DTPREL;
14390           goto dogot;
14391
14392         case R_PPC64_GOT16:
14393         case R_PPC64_GOT16_LO:
14394         case R_PPC64_GOT16_HI:
14395         case R_PPC64_GOT16_HA:
14396         case R_PPC64_GOT16_DS:
14397         case R_PPC64_GOT16_LO_DS:
14398         dogot:
14399           {
14400             /* Relocation is to the entry for this symbol in the global
14401                offset table.  */
14402             asection *got;
14403             bfd_vma *offp;
14404             bfd_vma off;
14405             unsigned long indx = 0;
14406             struct got_entry *ent;
14407
14408             if (tls_type == (TLS_TLS | TLS_LD)
14409                 && (h == NULL
14410                     || !h->elf.def_dynamic))
14411               ent = ppc64_tlsld_got (input_bfd);
14412             else
14413               {
14414                 if (h != NULL)
14415                   {
14416                     if (!htab->elf.dynamic_sections_created
14417                         || h->elf.dynindx == -1
14418                         || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14419                         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14420                       /* This is actually a static link, or it is a
14421                          -Bsymbolic link and the symbol is defined
14422                          locally, or the symbol was forced to be local
14423                          because of a version file.  */
14424                       ;
14425                     else
14426                       {
14427                         indx = h->elf.dynindx;
14428                         unresolved_reloc = FALSE;
14429                       }
14430                     ent = h->elf.got.glist;
14431                   }
14432                 else
14433                   {
14434                     if (local_got_ents == NULL)
14435                       abort ();
14436                     ent = local_got_ents[r_symndx];
14437                   }
14438
14439                 for (; ent != NULL; ent = ent->next)
14440                   if (ent->addend == orig_rel.r_addend
14441                       && ent->owner == input_bfd
14442                       && ent->tls_type == tls_type)
14443                     break;
14444               }
14445
14446             if (ent == NULL)
14447               abort ();
14448             if (ent->is_indirect)
14449               ent = ent->got.ent;
14450             offp = &ent->got.offset;
14451             got = ppc64_elf_tdata (ent->owner)->got;
14452             if (got == NULL)
14453               abort ();
14454
14455             /* The offset must always be a multiple of 8.  We use the
14456                least significant bit to record whether we have already
14457                processed this entry.  */
14458             off = *offp;
14459             if ((off & 1) != 0)
14460               off &= ~1;
14461             else
14462               {
14463                 /* Generate relocs for the dynamic linker, except in
14464                    the case of TLSLD where we'll use one entry per
14465                    module.  */
14466                 asection *relgot;
14467                 bfd_boolean ifunc;
14468
14469                 *offp = off | 1;
14470                 relgot = NULL;
14471                 ifunc = (h != NULL
14472                          ? h->elf.type == STT_GNU_IFUNC
14473                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14474                 if (ifunc)
14475                   {
14476                     relgot = htab->elf.irelplt;
14477                     if (indx == 0)
14478                       htab->local_ifunc_resolver = 1;
14479                     else if (is_static_defined (&h->elf))
14480                       htab->maybe_local_ifunc_resolver = 1;
14481                   }
14482                 else if (indx != 0
14483                          || (bfd_link_pic (info)
14484                              && (h == NULL
14485                                  || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14486                                  || (tls_type == (TLS_TLS | TLS_LD)
14487                                      && !h->elf.def_dynamic))))
14488                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14489                 if (relgot != NULL)
14490                   {
14491                     outrel.r_offset = (got->output_section->vma
14492                                        + got->output_offset
14493                                        + off);
14494                     outrel.r_addend = addend;
14495                     if (tls_type & (TLS_LD | TLS_GD))
14496                       {
14497                         outrel.r_addend = 0;
14498                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14499                         if (tls_type == (TLS_TLS | TLS_GD))
14500                           {
14501                             loc = relgot->contents;
14502                             loc += (relgot->reloc_count++
14503                                     * sizeof (Elf64_External_Rela));
14504                             bfd_elf64_swap_reloca_out (output_bfd,
14505                                                        &outrel, loc);
14506                             outrel.r_offset += 8;
14507                             outrel.r_addend = addend;
14508                             outrel.r_info
14509                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14510                           }
14511                       }
14512                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14513                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14514                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14515                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14516                     else if (indx != 0)
14517                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14518                     else
14519                       {
14520                         if (ifunc)
14521                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14522                         else
14523                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14524
14525                         /* Write the .got section contents for the sake
14526                            of prelink.  */
14527                         loc = got->contents + off;
14528                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14529                                     loc);
14530                       }
14531
14532                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14533                       {
14534                         outrel.r_addend += relocation;
14535                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14536                           {
14537                             if (htab->elf.tls_sec == NULL)
14538                               outrel.r_addend = 0;
14539                             else
14540                               outrel.r_addend -= htab->elf.tls_sec->vma;
14541                           }
14542                       }
14543                     loc = relgot->contents;
14544                     loc += (relgot->reloc_count++
14545                             * sizeof (Elf64_External_Rela));
14546                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14547                   }
14548
14549                 /* Init the .got section contents here if we're not
14550                    emitting a reloc.  */
14551                 else
14552                   {
14553                     relocation += addend;
14554                     if (tls_type != 0)
14555                       {
14556                         if (htab->elf.tls_sec == NULL)
14557                           relocation = 0;
14558                         else
14559                           {
14560                             if (tls_type & TLS_LD)
14561                               relocation = 0;
14562                             else
14563                               relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14564                             if (tls_type & TLS_TPREL)
14565                               relocation += DTP_OFFSET - TP_OFFSET;
14566                           }
14567
14568                         if (tls_type & (TLS_GD | TLS_LD))
14569                           {
14570                             bfd_put_64 (output_bfd, relocation,
14571                                         got->contents + off + 8);
14572                             relocation = 1;
14573                           }
14574                       }
14575                     bfd_put_64 (output_bfd, relocation,
14576                                 got->contents + off);
14577                   }
14578               }
14579
14580             if (off >= (bfd_vma) -2)
14581               abort ();
14582
14583             relocation = got->output_section->vma + got->output_offset + off;
14584             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14585           }
14586           break;
14587
14588         case R_PPC64_PLT16_HA:
14589         case R_PPC64_PLT16_HI:
14590         case R_PPC64_PLT16_LO:
14591         case R_PPC64_PLT32:
14592         case R_PPC64_PLT64:
14593           /* Relocation is to the entry for this symbol in the
14594              procedure linkage table.  */
14595           {
14596             struct plt_entry **plt_list = NULL;
14597             if (h != NULL)
14598               plt_list = &h->elf.plt.plist;
14599             else if (local_got_ents != NULL)
14600               {
14601                 struct plt_entry **local_plt = (struct plt_entry **)
14602                   (local_got_ents + symtab_hdr->sh_info);
14603                 unsigned char *local_got_tls_masks = (unsigned char *)
14604                   (local_plt + symtab_hdr->sh_info);
14605                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14606                   plt_list = local_plt + r_symndx;
14607               }
14608             if (plt_list)
14609               {
14610                 struct plt_entry *ent;
14611
14612                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14613                   if (ent->plt.offset != (bfd_vma) -1
14614                       && ent->addend == orig_rel.r_addend)
14615                     {
14616                       asection *plt;
14617
14618                       plt = htab->elf.splt;
14619                       if (!htab->elf.dynamic_sections_created
14620                           || h == NULL
14621                           || h->elf.dynindx == -1)
14622                         plt = htab->elf.iplt;
14623                       relocation = (plt->output_section->vma
14624                                     + plt->output_offset
14625                                     + ent->plt.offset);
14626                       addend = 0;
14627                       unresolved_reloc = FALSE;
14628                       break;
14629                     }
14630               }
14631           }
14632           break;
14633
14634         case R_PPC64_TOC:
14635           /* Relocation value is TOC base.  */
14636           relocation = TOCstart;
14637           if (r_symndx == STN_UNDEF)
14638             relocation += htab->sec_info[input_section->id].toc_off;
14639           else if (unresolved_reloc)
14640             ;
14641           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14642             relocation += htab->sec_info[sec->id].toc_off;
14643           else
14644             unresolved_reloc = TRUE;
14645           goto dodyn;
14646
14647           /* TOC16 relocs.  We want the offset relative to the TOC base,
14648              which is the address of the start of the TOC plus 0x8000.
14649              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14650              in this order.  */
14651         case R_PPC64_TOC16:
14652         case R_PPC64_TOC16_LO:
14653         case R_PPC64_TOC16_HI:
14654         case R_PPC64_TOC16_DS:
14655         case R_PPC64_TOC16_LO_DS:
14656         case R_PPC64_TOC16_HA:
14657           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14658           break;
14659
14660           /* Relocate against the beginning of the section.  */
14661         case R_PPC64_SECTOFF:
14662         case R_PPC64_SECTOFF_LO:
14663         case R_PPC64_SECTOFF_HI:
14664         case R_PPC64_SECTOFF_DS:
14665         case R_PPC64_SECTOFF_LO_DS:
14666         case R_PPC64_SECTOFF_HA:
14667           if (sec != NULL)
14668             addend -= sec->output_section->vma;
14669           break;
14670
14671         case R_PPC64_REL16:
14672         case R_PPC64_REL16_LO:
14673         case R_PPC64_REL16_HI:
14674         case R_PPC64_REL16_HA:
14675         case R_PPC64_REL16DX_HA:
14676           break;
14677
14678         case R_PPC64_REL14:
14679         case R_PPC64_REL14_BRNTAKEN:
14680         case R_PPC64_REL14_BRTAKEN:
14681         case R_PPC64_REL24:
14682           break;
14683
14684         case R_PPC64_TPREL16:
14685         case R_PPC64_TPREL16_LO:
14686         case R_PPC64_TPREL16_HI:
14687         case R_PPC64_TPREL16_HA:
14688         case R_PPC64_TPREL16_DS:
14689         case R_PPC64_TPREL16_LO_DS:
14690         case R_PPC64_TPREL16_HIGH:
14691         case R_PPC64_TPREL16_HIGHA:
14692         case R_PPC64_TPREL16_HIGHER:
14693         case R_PPC64_TPREL16_HIGHERA:
14694         case R_PPC64_TPREL16_HIGHEST:
14695         case R_PPC64_TPREL16_HIGHESTA:
14696           if (h != NULL
14697               && h->elf.root.type == bfd_link_hash_undefweak
14698               && h->elf.dynindx == -1)
14699             {
14700               /* Make this relocation against an undefined weak symbol
14701                  resolve to zero.  This is really just a tweak, since
14702                  code using weak externs ought to check that they are
14703                  defined before using them.  */
14704               bfd_byte *p = contents + rel->r_offset - d_offset;
14705
14706               insn = bfd_get_32 (input_bfd, p);
14707               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14708               if (insn != 0)
14709                 bfd_put_32 (input_bfd, insn, p);
14710               break;
14711             }
14712           if (htab->elf.tls_sec != NULL)
14713             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14714           /* The TPREL16 relocs shouldn't really be used in shared
14715              libs or with non-local symbols as that will result in
14716              DT_TEXTREL being set, but support them anyway.  */
14717           goto dodyn;
14718
14719         case R_PPC64_DTPREL16:
14720         case R_PPC64_DTPREL16_LO:
14721         case R_PPC64_DTPREL16_HI:
14722         case R_PPC64_DTPREL16_HA:
14723         case R_PPC64_DTPREL16_DS:
14724         case R_PPC64_DTPREL16_LO_DS:
14725         case R_PPC64_DTPREL16_HIGH:
14726         case R_PPC64_DTPREL16_HIGHA:
14727         case R_PPC64_DTPREL16_HIGHER:
14728         case R_PPC64_DTPREL16_HIGHERA:
14729         case R_PPC64_DTPREL16_HIGHEST:
14730         case R_PPC64_DTPREL16_HIGHESTA:
14731           if (htab->elf.tls_sec != NULL)
14732             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14733           break;
14734
14735         case R_PPC64_ADDR64_LOCAL:
14736           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14737                                               ? h->elf.other
14738                                               : sym->st_other);
14739           break;
14740
14741         case R_PPC64_DTPMOD64:
14742           relocation = 1;
14743           addend = 0;
14744           goto dodyn;
14745
14746         case R_PPC64_TPREL64:
14747           if (htab->elf.tls_sec != NULL)
14748             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14749           goto dodyn;
14750
14751         case R_PPC64_DTPREL64:
14752           if (htab->elf.tls_sec != NULL)
14753             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14754           /* Fall through.  */
14755
14756           /* Relocations that may need to be propagated if this is a
14757              dynamic object.  */
14758         case R_PPC64_REL30:
14759         case R_PPC64_REL32:
14760         case R_PPC64_REL64:
14761         case R_PPC64_ADDR14:
14762         case R_PPC64_ADDR14_BRNTAKEN:
14763         case R_PPC64_ADDR14_BRTAKEN:
14764         case R_PPC64_ADDR16:
14765         case R_PPC64_ADDR16_DS:
14766         case R_PPC64_ADDR16_HA:
14767         case R_PPC64_ADDR16_HI:
14768         case R_PPC64_ADDR16_HIGH:
14769         case R_PPC64_ADDR16_HIGHA:
14770         case R_PPC64_ADDR16_HIGHER:
14771         case R_PPC64_ADDR16_HIGHERA:
14772         case R_PPC64_ADDR16_HIGHEST:
14773         case R_PPC64_ADDR16_HIGHESTA:
14774         case R_PPC64_ADDR16_LO:
14775         case R_PPC64_ADDR16_LO_DS:
14776         case R_PPC64_ADDR24:
14777         case R_PPC64_ADDR32:
14778         case R_PPC64_ADDR64:
14779         case R_PPC64_UADDR16:
14780         case R_PPC64_UADDR32:
14781         case R_PPC64_UADDR64:
14782         dodyn:
14783           if ((input_section->flags & SEC_ALLOC) == 0)
14784             break;
14785
14786           if (NO_OPD_RELOCS && is_opd)
14787             break;
14788
14789           if (bfd_link_pic (info)
14790               ? ((h == NULL
14791                   || h->dyn_relocs != NULL)
14792                  && ((h != NULL && pc_dynrelocs (h))
14793                      || must_be_dyn_reloc (info, r_type)))
14794               : (h != NULL
14795                  ? h->dyn_relocs != NULL
14796                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14797             {
14798               bfd_boolean skip, relocate;
14799               asection *sreloc;
14800               bfd_vma out_off;
14801               long indx = 0;
14802
14803               /* When generating a dynamic object, these relocations
14804                  are copied into the output file to be resolved at run
14805                  time.  */
14806
14807               skip = FALSE;
14808               relocate = FALSE;
14809
14810               out_off = _bfd_elf_section_offset (output_bfd, info,
14811                                                  input_section, rel->r_offset);
14812               if (out_off == (bfd_vma) -1)
14813                 skip = TRUE;
14814               else if (out_off == (bfd_vma) -2)
14815                 skip = TRUE, relocate = TRUE;
14816               out_off += (input_section->output_section->vma
14817                           + input_section->output_offset);
14818               outrel.r_offset = out_off;
14819               outrel.r_addend = rel->r_addend;
14820
14821               /* Optimize unaligned reloc use.  */
14822               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14823                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14824                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14825               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14826                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14827                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14828               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14829                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14830                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14831
14832               if (skip)
14833                 memset (&outrel, 0, sizeof outrel);
14834               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14835                        && !is_opd
14836                        && r_type != R_PPC64_TOC)
14837                 {
14838                   indx = h->elf.dynindx;
14839                   BFD_ASSERT (indx != -1);
14840                   outrel.r_info = ELF64_R_INFO (indx, r_type);
14841                 }
14842               else
14843                 {
14844                   /* This symbol is local, or marked to become local,
14845                      or this is an opd section reloc which must point
14846                      at a local function.  */
14847                   outrel.r_addend += relocation;
14848                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14849                     {
14850                       if (is_opd && h != NULL)
14851                         {
14852                           /* Lie about opd entries.  This case occurs
14853                              when building shared libraries and we
14854                              reference a function in another shared
14855                              lib.  The same thing happens for a weak
14856                              definition in an application that's
14857                              overridden by a strong definition in a
14858                              shared lib.  (I believe this is a generic
14859                              bug in binutils handling of weak syms.)
14860                              In these cases we won't use the opd
14861                              entry in this lib.  */
14862                           unresolved_reloc = FALSE;
14863                         }
14864                       if (!is_opd
14865                           && r_type == R_PPC64_ADDR64
14866                           && (h != NULL
14867                               ? h->elf.type == STT_GNU_IFUNC
14868                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14869                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14870                       else
14871                         {
14872                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14873
14874                           /* We need to relocate .opd contents for ld.so.
14875                              Prelink also wants simple and consistent rules
14876                              for relocs.  This make all RELATIVE relocs have
14877                              *r_offset equal to r_addend.  */
14878                           relocate = TRUE;
14879                         }
14880                     }
14881                   else
14882                     {
14883                       if (h != NULL
14884                           ? h->elf.type == STT_GNU_IFUNC
14885                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14886                         {
14887                           info->callbacks->einfo
14888                             /* xgettext:c-format */
14889                             (_("%H: %s for indirect "
14890                                "function `%T' unsupported\n"),
14891                              input_bfd, input_section, rel->r_offset,
14892                              ppc64_elf_howto_table[r_type]->name,
14893                              sym_name);
14894                           ret = FALSE;
14895                         }
14896                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14897                         ;
14898                       else if (sec == NULL || sec->owner == NULL)
14899                         {
14900                           bfd_set_error (bfd_error_bad_value);
14901                           return FALSE;
14902                         }
14903                       else
14904                         {
14905                           asection *osec;
14906
14907                           osec = sec->output_section;
14908                           indx = elf_section_data (osec)->dynindx;
14909
14910                           if (indx == 0)
14911                             {
14912                               if ((osec->flags & SEC_READONLY) == 0
14913                                   && htab->elf.data_index_section != NULL)
14914                                 osec = htab->elf.data_index_section;
14915                               else
14916                                 osec = htab->elf.text_index_section;
14917                               indx = elf_section_data (osec)->dynindx;
14918                             }
14919                           BFD_ASSERT (indx != 0);
14920
14921                           /* We are turning this relocation into one
14922                              against a section symbol, so subtract out
14923                              the output section's address but not the
14924                              offset of the input section in the output
14925                              section.  */
14926                           outrel.r_addend -= osec->vma;
14927                         }
14928
14929                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14930                     }
14931                 }
14932
14933               sreloc = elf_section_data (input_section)->sreloc;
14934               if (h != NULL
14935                   ? h->elf.type == STT_GNU_IFUNC
14936                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14937                 {
14938                   sreloc = htab->elf.irelplt;
14939                   if (indx == 0)
14940                     htab->local_ifunc_resolver = 1;
14941                   else if (is_static_defined (&h->elf))
14942                     htab->maybe_local_ifunc_resolver = 1;
14943                 }
14944               if (sreloc == NULL)
14945                 abort ();
14946
14947               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14948                   >= sreloc->size)
14949                 abort ();
14950               loc = sreloc->contents;
14951               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14952               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14953
14954               /* If this reloc is against an external symbol, it will
14955                  be computed at runtime, so there's no need to do
14956                  anything now.  However, for the sake of prelink ensure
14957                  that the section contents are a known value.  */
14958               if (! relocate)
14959                 {
14960                   unresolved_reloc = FALSE;
14961                   /* The value chosen here is quite arbitrary as ld.so
14962                      ignores section contents except for the special
14963                      case of .opd where the contents might be accessed
14964                      before relocation.  Choose zero, as that won't
14965                      cause reloc overflow.  */
14966                   relocation = 0;
14967                   addend = 0;
14968                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14969                      to improve backward compatibility with older
14970                      versions of ld.  */
14971                   if (r_type == R_PPC64_ADDR64)
14972                     addend = outrel.r_addend;
14973                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14974                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14975                     addend = outrel.r_offset;
14976                 }
14977             }
14978           break;
14979
14980         case R_PPC64_COPY:
14981         case R_PPC64_GLOB_DAT:
14982         case R_PPC64_JMP_SLOT:
14983         case R_PPC64_JMP_IREL:
14984         case R_PPC64_RELATIVE:
14985           /* We shouldn't ever see these dynamic relocs in relocatable
14986              files.  */
14987           /* Fall through.  */
14988
14989         case R_PPC64_PLTGOT16:
14990         case R_PPC64_PLTGOT16_DS:
14991         case R_PPC64_PLTGOT16_HA:
14992         case R_PPC64_PLTGOT16_HI:
14993         case R_PPC64_PLTGOT16_LO:
14994         case R_PPC64_PLTGOT16_LO_DS:
14995         case R_PPC64_PLTREL32:
14996         case R_PPC64_PLTREL64:
14997           /* These ones haven't been implemented yet.  */
14998
14999           info->callbacks->einfo
15000             /* xgettext:c-format */
15001             (_("%P: %B: %s is not supported for `%T'\n"),
15002              input_bfd,
15003              ppc64_elf_howto_table[r_type]->name, sym_name);
15004
15005           bfd_set_error (bfd_error_invalid_operation);
15006           ret = FALSE;
15007           goto copy_reloc;
15008         }
15009
15010       /* Multi-instruction sequences that access the TOC can be
15011          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15012          to             nop;           addi rb,r2,x;  */
15013       howto = ppc64_elf_howto_table[(int) r_type];
15014       switch (r_type)
15015         {
15016         default:
15017           break;
15018
15019         case R_PPC64_GOT_TLSLD16_HI:
15020         case R_PPC64_GOT_TLSGD16_HI:
15021         case R_PPC64_GOT_TPREL16_HI:
15022         case R_PPC64_GOT_DTPREL16_HI:
15023         case R_PPC64_GOT16_HI:
15024         case R_PPC64_TOC16_HI:
15025           /* These relocs would only be useful if building up an
15026              offset to later add to r2, perhaps in an indexed
15027              addressing mode instruction.  Don't try to optimize.
15028              Unfortunately, the possibility of someone building up an
15029              offset like this or even with the HA relocs, means that
15030              we need to check the high insn when optimizing the low
15031              insn.  */
15032           break;
15033
15034         case R_PPC64_GOT_TLSLD16_HA:
15035         case R_PPC64_GOT_TLSGD16_HA:
15036         case R_PPC64_GOT_TPREL16_HA:
15037         case R_PPC64_GOT_DTPREL16_HA:
15038         case R_PPC64_GOT16_HA:
15039         case R_PPC64_TOC16_HA:
15040           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15041               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15042             {
15043               bfd_byte *p = contents + (rel->r_offset & ~3);
15044               bfd_put_32 (input_bfd, NOP, p);
15045             }
15046           break;
15047
15048         case R_PPC64_GOT_TLSLD16_LO:
15049         case R_PPC64_GOT_TLSGD16_LO:
15050         case R_PPC64_GOT_TPREL16_LO_DS:
15051         case R_PPC64_GOT_DTPREL16_LO_DS:
15052         case R_PPC64_GOT16_LO:
15053         case R_PPC64_GOT16_LO_DS:
15054         case R_PPC64_TOC16_LO:
15055         case R_PPC64_TOC16_LO_DS:
15056           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15057               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15058             {
15059               bfd_byte *p = contents + (rel->r_offset & ~3);
15060               insn = bfd_get_32 (input_bfd, p);
15061               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15062                 {
15063                   /* Transform addic to addi when we change reg.  */
15064                   insn &= ~((0x3f << 26) | (0x1f << 16));
15065                   insn |= (14u << 26) | (2 << 16);
15066                 }
15067               else
15068                 {
15069                   insn &= ~(0x1f << 16);
15070                   insn |= 2 << 16;
15071                 }
15072               bfd_put_32 (input_bfd, insn, p);
15073             }
15074           break;
15075
15076         case R_PPC64_TPREL16_HA:
15077           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15078             {
15079               bfd_byte *p = contents + (rel->r_offset & ~3);
15080               insn = bfd_get_32 (input_bfd, p);
15081               if ((insn & ((0x3f << 26) | 0x1f << 16))
15082                   != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15083                 /* xgettext:c-format */
15084                 info->callbacks->minfo
15085                   (_("%H: warning: %s unexpected insn %#x.\n"),
15086                    input_bfd, input_section, rel->r_offset, howto->name, insn);
15087               else
15088                 bfd_put_32 (input_bfd, NOP, p);
15089             }
15090           break;
15091
15092         case R_PPC64_TPREL16_LO:
15093         case R_PPC64_TPREL16_LO_DS:
15094           if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15095             {
15096               bfd_byte *p = contents + (rel->r_offset & ~3);
15097               insn = bfd_get_32 (input_bfd, p);
15098               insn &= ~(0x1f << 16);
15099               insn |= 13 << 16;
15100               bfd_put_32 (input_bfd, insn, p);
15101             }
15102           break;
15103         }
15104
15105       /* Do any further special processing.  */
15106       switch (r_type)
15107         {
15108         default:
15109           break;
15110
15111         case R_PPC64_REL16_HA:
15112         case R_PPC64_REL16DX_HA:
15113         case R_PPC64_ADDR16_HA:
15114         case R_PPC64_ADDR16_HIGHA:
15115         case R_PPC64_ADDR16_HIGHERA:
15116         case R_PPC64_ADDR16_HIGHESTA:
15117         case R_PPC64_TOC16_HA:
15118         case R_PPC64_SECTOFF_HA:
15119         case R_PPC64_TPREL16_HA:
15120         case R_PPC64_TPREL16_HIGHA:
15121         case R_PPC64_TPREL16_HIGHERA:
15122         case R_PPC64_TPREL16_HIGHESTA:
15123         case R_PPC64_DTPREL16_HA:
15124         case R_PPC64_DTPREL16_HIGHA:
15125         case R_PPC64_DTPREL16_HIGHERA:
15126         case R_PPC64_DTPREL16_HIGHESTA:
15127           /* It's just possible that this symbol is a weak symbol
15128              that's not actually defined anywhere. In that case,
15129              'sec' would be NULL, and we should leave the symbol
15130              alone (it will be set to zero elsewhere in the link).  */
15131           if (sec == NULL)
15132             break;
15133           /* Fall through.  */
15134
15135         case R_PPC64_GOT16_HA:
15136         case R_PPC64_PLTGOT16_HA:
15137         case R_PPC64_PLT16_HA:
15138         case R_PPC64_GOT_TLSGD16_HA:
15139         case R_PPC64_GOT_TLSLD16_HA:
15140         case R_PPC64_GOT_TPREL16_HA:
15141         case R_PPC64_GOT_DTPREL16_HA:
15142           /* Add 0x10000 if sign bit in 0:15 is set.
15143              Bits 0:15 are not used.  */
15144           addend += 0x8000;
15145           break;
15146
15147         case R_PPC64_ADDR16_DS:
15148         case R_PPC64_ADDR16_LO_DS:
15149         case R_PPC64_GOT16_DS:
15150         case R_PPC64_GOT16_LO_DS:
15151         case R_PPC64_PLT16_LO_DS:
15152         case R_PPC64_SECTOFF_DS:
15153         case R_PPC64_SECTOFF_LO_DS:
15154         case R_PPC64_TOC16_DS:
15155         case R_PPC64_TOC16_LO_DS:
15156         case R_PPC64_PLTGOT16_DS:
15157         case R_PPC64_PLTGOT16_LO_DS:
15158         case R_PPC64_GOT_TPREL16_DS:
15159         case R_PPC64_GOT_TPREL16_LO_DS:
15160         case R_PPC64_GOT_DTPREL16_DS:
15161         case R_PPC64_GOT_DTPREL16_LO_DS:
15162         case R_PPC64_TPREL16_DS:
15163         case R_PPC64_TPREL16_LO_DS:
15164         case R_PPC64_DTPREL16_DS:
15165         case R_PPC64_DTPREL16_LO_DS:
15166           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15167           mask = 3;
15168           /* If this reloc is against an lq, lxv, or stxv insn, then
15169              the value must be a multiple of 16.  This is somewhat of
15170              a hack, but the "correct" way to do this by defining _DQ
15171              forms of all the _DS relocs bloats all reloc switches in
15172              this file.  It doesn't make much sense to use these
15173              relocs in data, so testing the insn should be safe.  */
15174           if ((insn & (0x3f << 26)) == (56u << 26)
15175               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15176             mask = 15;
15177           relocation += addend;
15178           addend = insn & (mask ^ 3);
15179           if ((relocation & mask) != 0)
15180             {
15181               relocation ^= relocation & mask;
15182               info->callbacks->einfo
15183                 /* xgettext:c-format */
15184                 (_("%H: error: %s not a multiple of %u\n"),
15185                  input_bfd, input_section, rel->r_offset,
15186                  howto->name,
15187                  mask + 1);
15188               bfd_set_error (bfd_error_bad_value);
15189               ret = FALSE;
15190               goto copy_reloc;
15191             }
15192           break;
15193         }
15194
15195       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15196          because such sections are not SEC_ALLOC and thus ld.so will
15197          not process them.  */
15198       if (unresolved_reloc
15199           && !((input_section->flags & SEC_DEBUGGING) != 0
15200                && h->elf.def_dynamic)
15201           && _bfd_elf_section_offset (output_bfd, info, input_section,
15202                                       rel->r_offset) != (bfd_vma) -1)
15203         {
15204           info->callbacks->einfo
15205             /* xgettext:c-format */
15206             (_("%H: unresolvable %s against `%T'\n"),
15207              input_bfd, input_section, rel->r_offset,
15208              howto->name,
15209              h->elf.root.root.string);
15210           ret = FALSE;
15211         }
15212
15213       /* 16-bit fields in insns mostly have signed values, but a
15214          few insns have 16-bit unsigned values.  Really, we should
15215          have different reloc types.  */
15216       if (howto->complain_on_overflow != complain_overflow_dont
15217           && howto->dst_mask == 0xffff
15218           && (input_section->flags & SEC_CODE) != 0)
15219         {
15220           enum complain_overflow complain = complain_overflow_signed;
15221
15222           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15223           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15224             complain = complain_overflow_bitfield;
15225           else if (howto->rightshift == 0
15226                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15227                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15228                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15229                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15230                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15231                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15232             complain = complain_overflow_unsigned;
15233           if (howto->complain_on_overflow != complain)
15234             {
15235               alt_howto = *howto;
15236               alt_howto.complain_on_overflow = complain;
15237               howto = &alt_howto;
15238             }
15239         }
15240
15241       if (r_type == R_PPC64_REL16DX_HA)
15242         {
15243           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15244           if (rel->r_offset + 4 > input_section->size)
15245             r = bfd_reloc_outofrange;
15246           else
15247             {
15248               relocation += addend;
15249               relocation -= (rel->r_offset
15250                              + input_section->output_offset
15251                              + input_section->output_section->vma);
15252               relocation = (bfd_signed_vma) relocation >> 16;
15253               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15254               insn &= ~0x1fffc1;
15255               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15256               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15257               r = bfd_reloc_ok;
15258               if (relocation + 0x8000 > 0xffff)
15259                 r = bfd_reloc_overflow;
15260             }
15261         }
15262       else
15263         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15264                                       rel->r_offset, relocation, addend);
15265
15266       if (r != bfd_reloc_ok)
15267         {
15268           char *more_info = NULL;
15269           const char *reloc_name = howto->name;
15270
15271           if (reloc_dest != DEST_NORMAL)
15272             {
15273               more_info = bfd_malloc (strlen (reloc_name) + 8);
15274               if (more_info != NULL)
15275                 {
15276                   strcpy (more_info, reloc_name);
15277                   strcat (more_info, (reloc_dest == DEST_OPD
15278                                       ? " (OPD)" : " (stub)"));
15279                   reloc_name = more_info;
15280                 }
15281             }
15282
15283           if (r == bfd_reloc_overflow)
15284             {
15285               /* On code like "if (foo) foo();" don't report overflow
15286                  on a branch to zero when foo is undefined.  */
15287               if (!warned
15288                   && (reloc_dest == DEST_STUB
15289                       || !(h != NULL
15290                            && (h->elf.root.type == bfd_link_hash_undefweak
15291                                || h->elf.root.type == bfd_link_hash_undefined)
15292                            && is_branch_reloc (r_type))))
15293                 info->callbacks->reloc_overflow (info, &h->elf.root,
15294                                                  sym_name, reloc_name,
15295                                                  orig_rel.r_addend,
15296                                                  input_bfd, input_section,
15297                                                  rel->r_offset);
15298             }
15299           else
15300             {
15301               info->callbacks->einfo
15302                 /* xgettext:c-format */
15303                 (_("%H: %s against `%T': error %d\n"),
15304                  input_bfd, input_section, rel->r_offset,
15305                  reloc_name, sym_name, (int) r);
15306               ret = FALSE;
15307             }
15308           if (more_info != NULL)
15309             free (more_info);
15310         }
15311     copy_reloc:
15312       if (wrel != rel)
15313         *wrel = *rel;
15314     }
15315
15316   if (wrel != rel)
15317     {
15318       Elf_Internal_Shdr *rel_hdr;
15319       size_t deleted = rel - wrel;
15320
15321       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15322       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15323       if (rel_hdr->sh_size == 0)
15324         {
15325           /* It is too late to remove an empty reloc section.  Leave
15326              one NONE reloc.
15327              ??? What is wrong with an empty section???  */
15328           rel_hdr->sh_size = rel_hdr->sh_entsize;
15329           deleted -= 1;
15330         }
15331       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15332       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15333       input_section->reloc_count -= deleted;
15334     }
15335
15336   /* If we're emitting relocations, then shortly after this function
15337      returns, reloc offsets and addends for this section will be
15338      adjusted.  Worse, reloc symbol indices will be for the output
15339      file rather than the input.  Save a copy of the relocs for
15340      opd_entry_value.  */
15341   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15342     {
15343       bfd_size_type amt;
15344       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15345       rel = bfd_alloc (input_bfd, amt);
15346       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15347       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15348       if (rel == NULL)
15349         return FALSE;
15350       memcpy (rel, relocs, amt);
15351     }
15352   return ret;
15353 }
15354
15355 /* Adjust the value of any local symbols in opd sections.  */
15356
15357 static int
15358 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15359                               const char *name ATTRIBUTE_UNUSED,
15360                               Elf_Internal_Sym *elfsym,
15361                               asection *input_sec,
15362                               struct elf_link_hash_entry *h)
15363 {
15364   struct _opd_sec_data *opd;
15365   long adjust;
15366   bfd_vma value;
15367
15368   if (h != NULL)
15369     return 1;
15370
15371   opd = get_opd_info (input_sec);
15372   if (opd == NULL || opd->adjust == NULL)
15373     return 1;
15374
15375   value = elfsym->st_value - input_sec->output_offset;
15376   if (!bfd_link_relocatable (info))
15377     value -= input_sec->output_section->vma;
15378
15379   adjust = opd->adjust[OPD_NDX (value)];
15380   if (adjust == -1)
15381     return 2;
15382
15383   elfsym->st_value += adjust;
15384   return 1;
15385 }
15386
15387 /* Finish up dynamic symbol handling.  We set the contents of various
15388    dynamic sections here.  */
15389
15390 static bfd_boolean
15391 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15392                                  struct bfd_link_info *info,
15393                                  struct elf_link_hash_entry *h,
15394                                  Elf_Internal_Sym *sym)
15395 {
15396   struct ppc_link_hash_table *htab;
15397   struct plt_entry *ent;
15398   Elf_Internal_Rela rela;
15399   bfd_byte *loc;
15400
15401   htab = ppc_hash_table (info);
15402   if (htab == NULL)
15403     return FALSE;
15404
15405   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15406     if (ent->plt.offset != (bfd_vma) -1)
15407       {
15408         /* This symbol has an entry in the procedure linkage
15409            table.  Set it up.  */
15410         if (!htab->elf.dynamic_sections_created
15411             || h->dynindx == -1)
15412           {
15413             BFD_ASSERT (h->type == STT_GNU_IFUNC
15414                         && h->def_regular
15415                         && (h->root.type == bfd_link_hash_defined
15416                             || h->root.type == bfd_link_hash_defweak));
15417             rela.r_offset = (htab->elf.iplt->output_section->vma
15418                              + htab->elf.iplt->output_offset
15419                              + ent->plt.offset);
15420             if (htab->opd_abi)
15421               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15422             else
15423               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15424             rela.r_addend = (h->root.u.def.value
15425                              + h->root.u.def.section->output_offset
15426                              + h->root.u.def.section->output_section->vma
15427                              + ent->addend);
15428             loc = (htab->elf.irelplt->contents
15429                    + (htab->elf.irelplt->reloc_count++
15430                       * sizeof (Elf64_External_Rela)));
15431             htab->local_ifunc_resolver = 1;
15432           }
15433         else
15434           {
15435             rela.r_offset = (htab->elf.splt->output_section->vma
15436                              + htab->elf.splt->output_offset
15437                              + ent->plt.offset);
15438             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15439             rela.r_addend = ent->addend;
15440             loc = (htab->elf.srelplt->contents
15441                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15442                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15443             if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15444               htab->maybe_local_ifunc_resolver = 1;
15445           }
15446         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15447
15448         if (!htab->opd_abi)
15449           {
15450             if (!h->def_regular)
15451               {
15452                 /* Mark the symbol as undefined, rather than as
15453                    defined in glink.  Leave the value if there were
15454                    any relocations where pointer equality matters
15455                    (this is a clue for the dynamic linker, to make
15456                    function pointer comparisons work between an
15457                    application and shared library), otherwise set it
15458                    to zero.  */
15459                 sym->st_shndx = SHN_UNDEF;
15460                 if (!h->pointer_equality_needed)
15461                   sym->st_value = 0;
15462                 else if (!h->ref_regular_nonweak)
15463                   {
15464                     /* This breaks function pointer comparisons, but
15465                        that is better than breaking tests for a NULL
15466                        function pointer.  */
15467                     sym->st_value = 0;
15468                   }
15469               }
15470           }
15471       }
15472
15473   if (h->needs_copy)
15474     {
15475       /* This symbol needs a copy reloc.  Set it up.  */
15476       asection *srel;
15477
15478       if (h->dynindx == -1
15479           || (h->root.type != bfd_link_hash_defined
15480               && h->root.type != bfd_link_hash_defweak)
15481           || htab->elf.srelbss == NULL
15482           || htab->elf.sreldynrelro == NULL)
15483         abort ();
15484
15485       rela.r_offset = (h->root.u.def.value
15486                        + h->root.u.def.section->output_section->vma
15487                        + h->root.u.def.section->output_offset);
15488       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15489       rela.r_addend = 0;
15490       if (h->root.u.def.section == htab->elf.sdynrelro)
15491         srel = htab->elf.sreldynrelro;
15492       else
15493         srel = htab->elf.srelbss;
15494       loc = srel->contents;
15495       loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15496       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15497     }
15498
15499   return TRUE;
15500 }
15501
15502 /* Used to decide how to sort relocs in an optimal manner for the
15503    dynamic linker, before writing them out.  */
15504
15505 static enum elf_reloc_type_class
15506 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15507                             const asection *rel_sec,
15508                             const Elf_Internal_Rela *rela)
15509 {
15510   enum elf_ppc64_reloc_type r_type;
15511   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15512
15513   if (rel_sec == htab->elf.irelplt)
15514     return reloc_class_ifunc;
15515
15516   r_type = ELF64_R_TYPE (rela->r_info);
15517   switch (r_type)
15518     {
15519     case R_PPC64_RELATIVE:
15520       return reloc_class_relative;
15521     case R_PPC64_JMP_SLOT:
15522       return reloc_class_plt;
15523     case R_PPC64_COPY:
15524       return reloc_class_copy;
15525     default:
15526       return reloc_class_normal;
15527     }
15528 }
15529
15530 /* Finish up the dynamic sections.  */
15531
15532 static bfd_boolean
15533 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15534                                    struct bfd_link_info *info)
15535 {
15536   struct ppc_link_hash_table *htab;
15537   bfd *dynobj;
15538   asection *sdyn;
15539
15540   htab = ppc_hash_table (info);
15541   if (htab == NULL)
15542     return FALSE;
15543
15544   dynobj = htab->elf.dynobj;
15545   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15546
15547   if (htab->elf.dynamic_sections_created)
15548     {
15549       Elf64_External_Dyn *dyncon, *dynconend;
15550
15551       if (sdyn == NULL || htab->elf.sgot == NULL)
15552         abort ();
15553
15554       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15555       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15556       for (; dyncon < dynconend; dyncon++)
15557         {
15558           Elf_Internal_Dyn dyn;
15559           asection *s;
15560
15561           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15562
15563           switch (dyn.d_tag)
15564             {
15565             default:
15566               continue;
15567
15568             case DT_PPC64_GLINK:
15569               s = htab->glink;
15570               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15571               /* We stupidly defined DT_PPC64_GLINK to be the start
15572                  of glink rather than the first entry point, which is
15573                  what ld.so needs, and now have a bigger stub to
15574                  support automatic multiple TOCs.  */
15575               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15576               break;
15577
15578             case DT_PPC64_OPD:
15579               s = bfd_get_section_by_name (output_bfd, ".opd");
15580               if (s == NULL)
15581                 continue;
15582               dyn.d_un.d_ptr = s->vma;
15583               break;
15584
15585             case DT_PPC64_OPT:
15586               if (htab->do_multi_toc && htab->multi_toc_needed)
15587                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15588               if (htab->has_plt_localentry0)
15589                 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15590               break;
15591
15592             case DT_PPC64_OPDSZ:
15593               s = bfd_get_section_by_name (output_bfd, ".opd");
15594               if (s == NULL)
15595                 continue;
15596               dyn.d_un.d_val = s->size;
15597               break;
15598
15599             case DT_PLTGOT:
15600               s = htab->elf.splt;
15601               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15602               break;
15603
15604             case DT_JMPREL:
15605               s = htab->elf.srelplt;
15606               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15607               break;
15608
15609             case DT_PLTRELSZ:
15610               dyn.d_un.d_val = htab->elf.srelplt->size;
15611               break;
15612
15613             case DT_TEXTREL:
15614               if (htab->local_ifunc_resolver)
15615                 info->callbacks->einfo
15616                   (_("%X%P: text relocations and GNU indirect "
15617                      "functions will result in a segfault at runtime\n"));
15618               else if (htab->maybe_local_ifunc_resolver)
15619                 info->callbacks->einfo
15620                   (_("%P: warning: text relocations and GNU indirect "
15621                      "functions may result in a segfault at runtime\n"));
15622               continue;
15623             }
15624
15625           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15626         }
15627     }
15628
15629   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15630       && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15631     {
15632       /* Fill in the first entry in the global offset table.
15633          We use it to hold the link-time TOCbase.  */
15634       bfd_put_64 (output_bfd,
15635                   elf_gp (output_bfd) + TOC_BASE_OFF,
15636                   htab->elf.sgot->contents);
15637
15638       /* Set .got entry size.  */
15639       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15640     }
15641
15642   if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15643       && htab->elf.splt->output_section != bfd_abs_section_ptr)
15644     {
15645       /* Set .plt entry size.  */
15646       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15647         = PLT_ENTRY_SIZE (htab);
15648     }
15649
15650   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15651      brlt ourselves if emitrelocations.  */
15652   if (htab->brlt != NULL
15653       && htab->brlt->reloc_count != 0
15654       && !_bfd_elf_link_output_relocs (output_bfd,
15655                                        htab->brlt,
15656                                        elf_section_data (htab->brlt)->rela.hdr,
15657                                        elf_section_data (htab->brlt)->relocs,
15658                                        NULL))
15659     return FALSE;
15660
15661   if (htab->glink != NULL
15662       && htab->glink->reloc_count != 0
15663       && !_bfd_elf_link_output_relocs (output_bfd,
15664                                        htab->glink,
15665                                        elf_section_data (htab->glink)->rela.hdr,
15666                                        elf_section_data (htab->glink)->relocs,
15667                                        NULL))
15668     return FALSE;
15669
15670   if (htab->glink_eh_frame != NULL
15671       && htab->glink_eh_frame->size != 0)
15672     {
15673       bfd_vma val;
15674       bfd_byte *p;
15675       struct map_stub *group;
15676       size_t align = 4;
15677
15678       p = htab->glink_eh_frame->contents;
15679       p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15680
15681       for (group = htab->group; group != NULL; group = group->next)
15682         if (group->stub_sec != NULL)
15683           {
15684             /* Offset to stub section.  */
15685             val = (group->stub_sec->output_section->vma
15686                    + group->stub_sec->output_offset);
15687             val -= (htab->glink_eh_frame->output_section->vma
15688                     + htab->glink_eh_frame->output_offset
15689                     + (p + 8 - htab->glink_eh_frame->contents));
15690             if (val + 0x80000000 > 0xffffffff)
15691               {
15692                 info->callbacks->einfo
15693                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15694                    group->stub_sec->name);
15695                 return FALSE;
15696               }
15697             bfd_put_32 (dynobj, val, p + 8);
15698             p += stub_eh_frame_size (group, align);
15699           }
15700       if (htab->glink != NULL && htab->glink->size != 0)
15701         {
15702           /* Offset to .glink.  */
15703           val = (htab->glink->output_section->vma
15704                  + htab->glink->output_offset
15705                  + 8);
15706           val -= (htab->glink_eh_frame->output_section->vma
15707                   + htab->glink_eh_frame->output_offset
15708                   + (p + 8 - htab->glink_eh_frame->contents));
15709           if (val + 0x80000000 > 0xffffffff)
15710             {
15711               info->callbacks->einfo
15712                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15713                  htab->glink->name);
15714               return FALSE;
15715             }
15716           bfd_put_32 (dynobj, val, p + 8);
15717           p += (24 + align - 1) & -align;
15718         }
15719
15720       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15721           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15722                                                htab->glink_eh_frame,
15723                                                htab->glink_eh_frame->contents))
15724         return FALSE;
15725     }
15726
15727   /* We need to handle writing out multiple GOT sections ourselves,
15728      since we didn't add them to DYNOBJ.  We know dynobj is the first
15729      bfd.  */
15730   while ((dynobj = dynobj->link.next) != NULL)
15731     {
15732       asection *s;
15733
15734       if (!is_ppc64_elf (dynobj))
15735         continue;
15736
15737       s = ppc64_elf_tdata (dynobj)->got;
15738       if (s != NULL
15739           && s->size != 0
15740           && s->output_section != bfd_abs_section_ptr
15741           && !bfd_set_section_contents (output_bfd, s->output_section,
15742                                         s->contents, s->output_offset,
15743                                         s->size))
15744         return FALSE;
15745       s = ppc64_elf_tdata (dynobj)->relgot;
15746       if (s != NULL
15747           && s->size != 0
15748           && s->output_section != bfd_abs_section_ptr
15749           && !bfd_set_section_contents (output_bfd, s->output_section,
15750                                         s->contents, s->output_offset,
15751                                         s->size))
15752         return FALSE;
15753     }
15754
15755   return TRUE;
15756 }
15757
15758 #include "elf64-target.h"
15759
15760 /* FreeBSD support */
15761
15762 #undef  TARGET_LITTLE_SYM
15763 #undef  TARGET_LITTLE_NAME
15764
15765 #undef  TARGET_BIG_SYM
15766 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15767 #undef  TARGET_BIG_NAME
15768 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15769
15770 #undef  ELF_OSABI
15771 #define ELF_OSABI       ELFOSABI_FREEBSD
15772
15773 #undef  elf64_bed
15774 #define elf64_bed       elf64_powerpc_fbsd_bed
15775
15776 #include "elf64-target.h"