bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2014 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      0x1000
  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_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  99 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 109 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 110 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 111 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 112 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 113 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 114 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 115 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 116 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 117 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 118 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 119 #define elf_backend_special_sections          ppc64_elf_special_sections
 120 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 121
 122 /* The name of the dynamic interpreter.  This is put in the .interp
 123    section.  */
 124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 125
 126 /* The size in bytes of an entry in the procedure linkage table.  */
 127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 128
 129 /* The initial size of the plt reserved for the dynamic linker.  */
 130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 131
 132 /* Offsets to some stack save slots.  */
 133 #define STK_LR 16
 134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 135 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 136    CR save slot.  Used only by optimised __tls_get_addr call stub,
 137    relying on __tls_get_addr_opt not saving CR..  */
 138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 139
 140 /* TOC base pointers offset from start of TOC.  */
 141 #define TOC_BASE_OFF    0x8000
 142
 143 /* Offset of tp and dtp pointers from start of TLS block.  */
 144 #define TP_OFFSET       0x7000
 145 #define DTP_OFFSET      0x8000
 146
 147 /* .plt call stub instructions.  The normal stub is like this, but
 148    sometimes the .plt entry crosses a 64k boundary and we need to
 149    insert an addi to adjust r11.  */
 150 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 151 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 152 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 153 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 154 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 155 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 156 #define BCTR            0x4e800420      /* bctr                      */
 157
 158 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 159 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 160 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 161
 162 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 163 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 164 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 165 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 166 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 167 #define BNECTR          0x4ca20420      /* bnectr+               */
 168 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 169
 170 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 171 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 172 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 173
 174 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 175
 176 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 177 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 178 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 179
 180 /* glink call stub instructions.  We enter with the index in R0.  */
 181 #define GLINK_CALL_STUB_SIZE (16*4)
 182                                         /* 0:                           */
 183                                         /*  .quad plt0-1f               */
 184                                         /* __glink:                     */
 185 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 186 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 187                                         /* 1:                           */
 188 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 189                                         /*  ld %2,(0b-1b)(%11)          */
 190 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 191 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 192                                         /*  ld %12,0(%11)               */
 193                                         /*  ld %2,8(%11)                */
 194                                         /*  mtctr %12                   */
 195                                         /*  ld %11,16(%11)              */
 196                                         /*  bctr                        */
 197 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 198 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 199 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 200 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 201 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 202
 203 /* Pad with this.  */
 204 #define NOP             0x60000000
 205
 206 /* Some other nops.  */
 207 #define CROR_151515     0x4def7b82
 208 #define CROR_313131     0x4ffffb82
 209
 210 /* .glink entries for the first 32k functions are two instructions.  */
 211 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 212 #define B_DOT           0x48000000      /* b     .              */
 213
 214 /* After that, we need two instructions to load the index, followed by
 215    a branch.  */
 216 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 217 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 218
 219 /* Instructions used by the save and restore reg functions.  */
 220 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 221 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 222 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 223 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 224 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 225 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 226 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 227 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 228 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 229 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 230 #define BLR             0x4e800020      /* blr                  */
 231
 232 /* Since .opd is an array of descriptors and each entry will end up
 233    with identical R_PPC64_RELATIVE relocs, there is really no need to
 234    propagate .opd relocs;  The dynamic linker should be taught to
 235    relocate .opd without reloc entries.  */
 236 #ifndef NO_OPD_RELOCS
 237 #define NO_OPD_RELOCS 0
 238 #endif
 239 \f
 240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 241
 242 /* Relocation HOWTO's.  */
 243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 244
 245 static reloc_howto_type ppc64_elf_howto_raw[] = {
 246   /* This reloc does nothing.  */
 247   HOWTO (R_PPC64_NONE,          /* type */
 248          0,                     /* rightshift */
 249          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          32,                    /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_dont, /* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_PPC64_NONE",        /* name */
 256          FALSE,                 /* partial_inplace */
 257          0,                     /* src_mask */
 258          0,                     /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* A standard 32 bit relocation.  */
 262   HOWTO (R_PPC64_ADDR32,        /* type */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          32,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield, /* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_PPC64_ADDR32",      /* name */
 271          FALSE,                 /* partial_inplace */
 272          0,                     /* src_mask */
 273          0xffffffff,            /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* An absolute 26 bit branch; the lower two bits must be zero.
 277      FIXME: we don't check that, we just clear them.  */
 278   HOWTO (R_PPC64_ADDR24,        /* type */
 279          0,                     /* rightshift */
 280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          26,                    /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_bitfield, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_ADDR24",      /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0x03fffffc,            /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 16 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR16,        /* type */
 294          0,                     /* rightshift */
 295          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          16,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR16",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffff,                /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* A 16 bit relocation without overflow.  */
 308   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 309          0,                     /* rightshift */
 310          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          16,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_dont,/* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_PPC64_ADDR16_LO",   /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0xffff,                /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   /* Bits 16-31 of an address.  */
 323   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 324          16,                    /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_signed, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_PPC64_ADDR16_HI",   /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 338      bits, treated as a signed number, is negative.  */
 339   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 340          16,                    /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_signed, /* complain_on_overflow */
 346          ppc64_elf_ha_reloc,    /* special_function */
 347          "R_PPC64_ADDR16_HA",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* An absolute 16 bit branch; the lower two bits must be zero.
 354      FIXME: we don't check that, we just clear them.  */
 355   HOWTO (R_PPC64_ADDR14,        /* type */
 356          0,                     /* rightshift */
 357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          FALSE,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_signed, /* complain_on_overflow */
 362          ppc64_elf_branch_reloc, /* special_function */
 363          "R_PPC64_ADDR14",      /* name */
 364          FALSE,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0x0000fffc,            /* dst_mask */
 367          FALSE),                /* pcrel_offset */
 368
 369   /* An absolute 16 bit branch, for which bit 10 should be set to
 370      indicate that the branch is expected to be taken.  The lower two
 371      bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          16,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_signed, /* complain_on_overflow */
 379          ppc64_elf_brtaken_reloc, /* special_function */
 380          "R_PPC64_ADDR14_BRTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* An absolute 16 bit branch, for which bit 10 should be set to
 387      indicate that the branch is not expected to be taken.  The lower
 388      two bits must be zero.  */
 389   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 390          0,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          16,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_signed, /* complain_on_overflow */
 396          ppc64_elf_brtaken_reloc, /* special_function */
 397          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 398          FALSE,                 /* partial_inplace */
 399          0,                     /* src_mask */
 400          0x0000fffc,            /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403   /* A relative 26 bit branch; the lower two bits must be zero.  */
 404   HOWTO (R_PPC64_REL24,         /* type */
 405          0,                     /* rightshift */
 406          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          26,                    /* bitsize */
 408          TRUE,                  /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_signed, /* complain_on_overflow */
 411          ppc64_elf_branch_reloc, /* special_function */
 412          "R_PPC64_REL24",       /* name */
 413          FALSE,                 /* partial_inplace */
 414          0,                     /* src_mask */
 415          0x03fffffc,            /* dst_mask */
 416          TRUE),                 /* pcrel_offset */
 417
 418   /* A relative 16 bit branch; the lower two bits must be zero.  */
 419   HOWTO (R_PPC64_REL14,         /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          TRUE,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_branch_reloc, /* special_function */
 427          "R_PPC64_REL14",       /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          TRUE),                 /* pcrel_offset */
 432
 433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 434      the branch is expected to be taken.  The lower two bits must be
 435      zero.  */
 436   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          ppc64_elf_brtaken_reloc, /* special_function */
 444          "R_PPC64_REL14_BRTAKEN", /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 451      the branch is not expected to be taken.  The lower two bits must
 452      be zero.  */
 453   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          16,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          ppc64_elf_brtaken_reloc, /* special_function */
 461          "R_PPC64_REL14_BRNTAKEN",/* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0x0000fffc,            /* dst_mask */
 465          TRUE),                 /* pcrel_offset */
 466
 467   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 468      symbol.  */
 469   HOWTO (R_PPC64_GOT16,         /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_signed, /* complain_on_overflow */
 476          ppc64_elf_unhandled_reloc, /* special_function */
 477          "R_PPC64_GOT16",       /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0xffff,                /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 484      the symbol.  */
 485   HOWTO (R_PPC64_GOT16_LO,      /* type */
 486          0,                     /* rightshift */
 487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          ppc64_elf_unhandled_reloc, /* special_function */
 493          "R_PPC64_GOT16_LO",    /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 500      the symbol.  */
 501   HOWTO (R_PPC64_GOT16_HI,      /* type */
 502          16,                    /* rightshift */
 503          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_signed,/* complain_on_overflow */
 508          ppc64_elf_unhandled_reloc, /* special_function */
 509          "R_PPC64_GOT16_HI",    /* name */
 510          FALSE,                 /* partial_inplace */
 511          0,                     /* src_mask */
 512          0xffff,                /* dst_mask */
 513          FALSE),                /* pcrel_offset */
 514
 515   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 516      the symbol.  */
 517   HOWTO (R_PPC64_GOT16_HA,      /* type */
 518          16,                    /* rightshift */
 519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 520          16,                    /* bitsize */
 521          FALSE,                 /* pc_relative */
 522          0,                     /* bitpos */
 523          complain_overflow_signed,/* complain_on_overflow */
 524          ppc64_elf_unhandled_reloc, /* special_function */
 525          "R_PPC64_GOT16_HA",    /* name */
 526          FALSE,                 /* partial_inplace */
 527          0,                     /* src_mask */
 528          0xffff,                /* dst_mask */
 529          FALSE),                /* pcrel_offset */
 530
 531   /* This is used only by the dynamic linker.  The symbol should exist
 532      both in the object being run and in some shared library.  The
 533      dynamic linker copies the data addressed by the symbol from the
 534      shared library into the object, because the object being
 535      run has to have the data at some particular address.  */
 536   HOWTO (R_PPC64_COPY,          /* type */
 537          0,                     /* rightshift */
 538          0,                     /* this one is variable size */
 539          0,                     /* bitsize */
 540          FALSE,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont, /* complain_on_overflow */
 543          ppc64_elf_unhandled_reloc, /* special_function */
 544          "R_PPC64_COPY",        /* name */
 545          FALSE,                 /* partial_inplace */
 546          0,                     /* src_mask */
 547          0,                     /* dst_mask */
 548          FALSE),                /* pcrel_offset */
 549
 550   /* Like R_PPC64_ADDR64, but used when setting global offset table
 551      entries.  */
 552   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 553          0,                     /* rightshift */
 554          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 555          64,                    /* bitsize */
 556          FALSE,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          ppc64_elf_unhandled_reloc,  /* special_function */
 560          "R_PPC64_GLOB_DAT",    /* name */
 561          FALSE,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          ONES (64),             /* dst_mask */
 564          FALSE),                /* pcrel_offset */
 565
 566   /* Created by the link editor.  Marks a procedure linkage table
 567      entry for a symbol.  */
 568   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 569          0,                     /* rightshift */
 570          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          0,                     /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          ppc64_elf_unhandled_reloc, /* special_function */
 576          "R_PPC64_JMP_SLOT",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          0,                     /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Used only by the dynamic linker.  When the object is run, this
 583      doubleword64 is set to the load address of the object, plus the
 584      addend.  */
 585   HOWTO (R_PPC64_RELATIVE,      /* type */
 586          0,                     /* rightshift */
 587          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 588          64,                    /* bitsize */
 589          FALSE,                 /* pc_relative */
 590          0,                     /* bitpos */
 591          complain_overflow_dont, /* complain_on_overflow */
 592          bfd_elf_generic_reloc, /* special_function */
 593          "R_PPC64_RELATIVE",    /* name */
 594          FALSE,                 /* partial_inplace */
 595          0,                     /* src_mask */
 596          ONES (64),             /* dst_mask */
 597          FALSE),                /* pcrel_offset */
 598
 599   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 600   HOWTO (R_PPC64_UADDR32,       /* type */
 601          0,                     /* rightshift */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 603          32,                    /* bitsize */
 604          FALSE,                 /* pc_relative */
 605          0,                     /* bitpos */
 606          complain_overflow_bitfield, /* complain_on_overflow */
 607          bfd_elf_generic_reloc, /* special_function */
 608          "R_PPC64_UADDR32",     /* name */
 609          FALSE,                 /* partial_inplace */
 610          0,                     /* src_mask */
 611          0xffffffff,            /* dst_mask */
 612          FALSE),                /* pcrel_offset */
 613
 614   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 615   HOWTO (R_PPC64_UADDR16,       /* type */
 616          0,                     /* rightshift */
 617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 618          16,                    /* bitsize */
 619          FALSE,                 /* pc_relative */
 620          0,                     /* bitpos */
 621          complain_overflow_bitfield, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_UADDR16",     /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          0xffff,                /* dst_mask */
 627          FALSE),                /* pcrel_offset */
 628
 629   /* 32-bit PC relative.  */
 630   HOWTO (R_PPC64_REL32,         /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          TRUE,                  /* pc_relative */
 635          0,                     /* bitpos */
 636          complain_overflow_signed, /* complain_on_overflow */
 637          bfd_elf_generic_reloc, /* special_function */
 638          "R_PPC64_REL32",       /* name */
 639          FALSE,                 /* partial_inplace */
 640          0,                     /* src_mask */
 641          0xffffffff,            /* dst_mask */
 642          TRUE),                 /* pcrel_offset */
 643
 644   /* 32-bit relocation to the symbol's procedure linkage table.  */
 645   HOWTO (R_PPC64_PLT32,         /* type */
 646          0,                     /* rightshift */
 647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          32,                    /* bitsize */
 649          FALSE,                 /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_bitfield, /* complain_on_overflow */
 652          ppc64_elf_unhandled_reloc, /* special_function */
 653          "R_PPC64_PLT32",       /* name */
 654          FALSE,                 /* partial_inplace */
 655          0,                     /* src_mask */
 656          0xffffffff,            /* dst_mask */
 657          FALSE),                /* pcrel_offset */
 658
 659   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 660      FIXME: R_PPC64_PLTREL32 not supported.  */
 661   HOWTO (R_PPC64_PLTREL32,      /* type */
 662          0,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          32,                    /* bitsize */
 665          TRUE,                  /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_signed, /* complain_on_overflow */
 668          bfd_elf_generic_reloc, /* special_function */
 669          "R_PPC64_PLTREL32",    /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffffffff,            /* dst_mask */
 673          TRUE),                 /* pcrel_offset */
 674
 675   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 676      the symbol.  */
 677   HOWTO (R_PPC64_PLT16_LO,      /* type */
 678          0,                     /* rightshift */
 679          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          16,                    /* bitsize */
 681          FALSE,                 /* pc_relative */
 682          0,                     /* bitpos */
 683          complain_overflow_dont, /* complain_on_overflow */
 684          ppc64_elf_unhandled_reloc, /* special_function */
 685          "R_PPC64_PLT16_LO",    /* name */
 686          FALSE,                 /* partial_inplace */
 687          0,                     /* src_mask */
 688          0xffff,                /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 692      the symbol.  */
 693   HOWTO (R_PPC64_PLT16_HI,      /* type */
 694          16,                    /* rightshift */
 695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 696          16,                    /* bitsize */
 697          FALSE,                 /* pc_relative */
 698          0,                     /* bitpos */
 699          complain_overflow_signed, /* complain_on_overflow */
 700          ppc64_elf_unhandled_reloc, /* special_function */
 701          "R_PPC64_PLT16_HI",    /* name */
 702          FALSE,                 /* partial_inplace */
 703          0,                     /* src_mask */
 704          0xffff,                /* dst_mask */
 705          FALSE),                /* pcrel_offset */
 706
 707   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 708      the symbol.  */
 709   HOWTO (R_PPC64_PLT16_HA,      /* type */
 710          16,                    /* rightshift */
 711          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 712          16,                    /* bitsize */
 713          FALSE,                 /* pc_relative */
 714          0,                     /* bitpos */
 715          complain_overflow_signed, /* complain_on_overflow */
 716          ppc64_elf_unhandled_reloc, /* special_function */
 717          "R_PPC64_PLT16_HA",    /* name */
 718          FALSE,                 /* partial_inplace */
 719          0,                     /* src_mask */
 720          0xffff,                /* dst_mask */
 721          FALSE),                /* pcrel_offset */
 722
 723   /* 16-bit section relative relocation.  */
 724   HOWTO (R_PPC64_SECTOFF,       /* type */
 725          0,                     /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_signed, /* complain_on_overflow */
 731          ppc64_elf_sectoff_reloc, /* special_function */
 732          "R_PPC64_SECTOFF",     /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 739   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 740          0,                     /* rightshift */
 741          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 742          16,                    /* bitsize */
 743          FALSE,                 /* pc_relative */
 744          0,                     /* bitpos */
 745          complain_overflow_dont, /* complain_on_overflow */
 746          ppc64_elf_sectoff_reloc, /* special_function */
 747          "R_PPC64_SECTOFF_LO",  /* name */
 748          FALSE,                 /* partial_inplace */
 749          0,                     /* src_mask */
 750          0xffff,                /* dst_mask */
 751          FALSE),                /* pcrel_offset */
 752
 753   /* 16-bit upper half section relative relocation.  */
 754   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 755          16,                    /* rightshift */
 756          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          16,                    /* bitsize */
 758          FALSE,                 /* pc_relative */
 759          0,                     /* bitpos */
 760          complain_overflow_signed, /* complain_on_overflow */
 761          ppc64_elf_sectoff_reloc, /* special_function */
 762          "R_PPC64_SECTOFF_HI",  /* name */
 763          FALSE,                 /* partial_inplace */
 764          0,                     /* src_mask */
 765          0xffff,                /* dst_mask */
 766          FALSE),                /* pcrel_offset */
 767
 768   /* 16-bit upper half adjusted section relative relocation.  */
 769   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 770          16,                    /* rightshift */
 771          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 772          16,                    /* bitsize */
 773          FALSE,                 /* pc_relative */
 774          0,                     /* bitpos */
 775          complain_overflow_signed, /* complain_on_overflow */
 776          ppc64_elf_sectoff_ha_reloc, /* special_function */
 777          "R_PPC64_SECTOFF_HA",  /* name */
 778          FALSE,                 /* partial_inplace */
 779          0,                     /* src_mask */
 780          0xffff,                /* dst_mask */
 781          FALSE),                /* pcrel_offset */
 782
 783   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 784   HOWTO (R_PPC64_REL30,         /* type */
 785          2,                     /* rightshift */
 786          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 787          30,                    /* bitsize */
 788          TRUE,                  /* pc_relative */
 789          0,                     /* bitpos */
 790          complain_overflow_dont, /* complain_on_overflow */
 791          bfd_elf_generic_reloc, /* special_function */
 792          "R_PPC64_REL30",       /* name */
 793          FALSE,                 /* partial_inplace */
 794          0,                     /* src_mask */
 795          0xfffffffc,            /* dst_mask */
 796          TRUE),                 /* pcrel_offset */
 797
 798   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 799
 800   /* A standard 64-bit relocation.  */
 801   HOWTO (R_PPC64_ADDR64,        /* type */
 802          0,                     /* rightshift */
 803          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 804          64,                    /* bitsize */
 805          FALSE,                 /* pc_relative */
 806          0,                     /* bitpos */
 807          complain_overflow_dont, /* complain_on_overflow */
 808          bfd_elf_generic_reloc, /* special_function */
 809          "R_PPC64_ADDR64",      /* name */
 810          FALSE,                 /* partial_inplace */
 811          0,                     /* src_mask */
 812          ONES (64),             /* dst_mask */
 813          FALSE),                /* pcrel_offset */
 814
 815   /* The bits 32-47 of an address.  */
 816   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 817          32,                    /* rightshift */
 818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          16,                    /* bitsize */
 820          FALSE,                 /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_dont, /* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_PPC64_ADDR16_HIGHER", /* name */
 825          FALSE,                 /* partial_inplace */
 826          0,                     /* src_mask */
 827          0xffff,                /* dst_mask */
 828          FALSE),                /* pcrel_offset */
 829
 830   /* The bits 32-47 of an address, plus 1 if the contents of the low
 831      16 bits, treated as a signed number, is negative.  */
 832   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 833          32,                    /* rightshift */
 834          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 835          16,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          ppc64_elf_ha_reloc,    /* special_function */
 840          "R_PPC64_ADDR16_HIGHERA", /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          0xffff,                /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 48-63 of an address.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 848          48,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_PPC64_ADDR16_HIGHEST", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* The bits 48-63 of an address, plus 1 if the contents of the low
 862      16 bits, treated as a signed number, is negative.  */
 863   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 864          48,                    /* rightshift */
 865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          16,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          ppc64_elf_ha_reloc,    /* special_function */
 871          "R_PPC64_ADDR16_HIGHESTA", /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          0xffff,                /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* Like ADDR64, but may be unaligned.  */
 878   HOWTO (R_PPC64_UADDR64,       /* type */
 879          0,                     /* rightshift */
 880          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 881          64,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_UADDR64",     /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          ONES (64),             /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   /* 64-bit relative relocation.  */
 893   HOWTO (R_PPC64_REL64,         /* type */
 894          0,                     /* rightshift */
 895          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 896          64,                    /* bitsize */
 897          TRUE,                  /* pc_relative */
 898          0,                     /* bitpos */
 899          complain_overflow_dont, /* complain_on_overflow */
 900          bfd_elf_generic_reloc, /* special_function */
 901          "R_PPC64_REL64",       /* name */
 902          FALSE,                 /* partial_inplace */
 903          0,                     /* src_mask */
 904          ONES (64),             /* dst_mask */
 905          TRUE),                 /* pcrel_offset */
 906
 907   /* 64-bit relocation to the symbol's procedure linkage table.  */
 908   HOWTO (R_PPC64_PLT64,         /* type */
 909          0,                     /* rightshift */
 910          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 911          64,                    /* bitsize */
 912          FALSE,                 /* pc_relative */
 913          0,                     /* bitpos */
 914          complain_overflow_dont, /* complain_on_overflow */
 915          ppc64_elf_unhandled_reloc, /* special_function */
 916          "R_PPC64_PLT64",       /* name */
 917          FALSE,                 /* partial_inplace */
 918          0,                     /* src_mask */
 919          ONES (64),             /* dst_mask */
 920          FALSE),                /* pcrel_offset */
 921
 922   /* 64-bit PC relative relocation to the symbol's procedure linkage
 923      table.  */
 924   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 925   HOWTO (R_PPC64_PLTREL64,      /* type */
 926          0,                     /* rightshift */
 927          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 928          64,                    /* bitsize */
 929          TRUE,                  /* pc_relative */
 930          0,                     /* bitpos */
 931          complain_overflow_dont, /* complain_on_overflow */
 932          ppc64_elf_unhandled_reloc, /* special_function */
 933          "R_PPC64_PLTREL64",    /* name */
 934          FALSE,                 /* partial_inplace */
 935          0,                     /* src_mask */
 936          ONES (64),             /* dst_mask */
 937          TRUE),                 /* pcrel_offset */
 938
 939   /* 16 bit TOC-relative relocation.  */
 940
 941   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 942   HOWTO (R_PPC64_TOC16,         /* type */
 943          0,                     /* rightshift */
 944          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 945          16,                    /* bitsize */
 946          FALSE,                 /* pc_relative */
 947          0,                     /* bitpos */
 948          complain_overflow_signed, /* complain_on_overflow */
 949          ppc64_elf_toc_reloc,   /* special_function */
 950          "R_PPC64_TOC16",       /* name */
 951          FALSE,                 /* partial_inplace */
 952          0,                     /* src_mask */
 953          0xffff,                /* dst_mask */
 954          FALSE),                /* pcrel_offset */
 955
 956   /* 16 bit TOC-relative relocation without overflow.  */
 957
 958   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 959   HOWTO (R_PPC64_TOC16_LO,      /* type */
 960          0,                     /* rightshift */
 961          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 962          16,                    /* bitsize */
 963          FALSE,                 /* pc_relative */
 964          0,                     /* bitpos */
 965          complain_overflow_dont, /* complain_on_overflow */
 966          ppc64_elf_toc_reloc,   /* special_function */
 967          "R_PPC64_TOC16_LO",    /* name */
 968          FALSE,                 /* partial_inplace */
 969          0,                     /* src_mask */
 970          0xffff,                /* dst_mask */
 971          FALSE),                /* pcrel_offset */
 972
 973   /* 16 bit TOC-relative relocation, high 16 bits.  */
 974
 975   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 976   HOWTO (R_PPC64_TOC16_HI,      /* type */
 977          16,                    /* rightshift */
 978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 979          16,                    /* bitsize */
 980          FALSE,                 /* pc_relative */
 981          0,                     /* bitpos */
 982          complain_overflow_signed, /* complain_on_overflow */
 983          ppc64_elf_toc_reloc,   /* special_function */
 984          "R_PPC64_TOC16_HI",    /* name */
 985          FALSE,                 /* partial_inplace */
 986          0,                     /* src_mask */
 987          0xffff,                /* dst_mask */
 988          FALSE),                /* pcrel_offset */
 989
 990   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 991      contents of the low 16 bits, treated as a signed number, is
 992      negative.  */
 993
 994   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 995   HOWTO (R_PPC64_TOC16_HA,      /* type */
 996          16,                    /* rightshift */
 997          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 998          16,                    /* bitsize */
 999          FALSE,                 /* pc_relative */
1000          0,                     /* bitpos */
1001          complain_overflow_signed, /* complain_on_overflow */
1002          ppc64_elf_toc_ha_reloc, /* special_function */
1003          "R_PPC64_TOC16_HA",    /* name */
1004          FALSE,                 /* partial_inplace */
1005          0,                     /* src_mask */
1006          0xffff,                /* dst_mask */
1007          FALSE),                /* pcrel_offset */
1008
1009   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1010
1011   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1012   HOWTO (R_PPC64_TOC,           /* type */
1013          0,                     /* rightshift */
1014          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1015          64,                    /* bitsize */
1016          FALSE,                 /* pc_relative */
1017          0,                     /* bitpos */
1018          complain_overflow_dont, /* complain_on_overflow */
1019          ppc64_elf_toc64_reloc, /* special_function */
1020          "R_PPC64_TOC",         /* name */
1021          FALSE,                 /* partial_inplace */
1022          0,                     /* src_mask */
1023          ONES (64),             /* dst_mask */
1024          FALSE),                /* pcrel_offset */
1025
1026   /* Like R_PPC64_GOT16, but also informs the link editor that the
1027      value to relocate may (!) refer to a PLT entry which the link
1028      editor (a) may replace with the symbol value.  If the link editor
1029      is unable to fully resolve the symbol, it may (b) create a PLT
1030      entry and store the address to the new PLT entry in the GOT.
1031      This permits lazy resolution of function symbols at run time.
1032      The link editor may also skip all of this and just (c) emit a
1033      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1034   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1035     HOWTO (R_PPC64_PLTGOT16,    /* type */
1036          0,                     /* rightshift */
1037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          16,                    /* bitsize */
1039          FALSE,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_signed, /* complain_on_overflow */
1042          ppc64_elf_unhandled_reloc, /* special_function */
1043          "R_PPC64_PLTGOT16",    /* name */
1044          FALSE,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          0xffff,                /* dst_mask */
1047          FALSE),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1050   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1051   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1052          0,                     /* rightshift */
1053          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1054          16,                    /* bitsize */
1055          FALSE,                 /* pc_relative */
1056          0,                     /* bitpos */
1057          complain_overflow_dont, /* complain_on_overflow */
1058          ppc64_elf_unhandled_reloc, /* special_function */
1059          "R_PPC64_PLTGOT16_LO", /* name */
1060          FALSE,                 /* partial_inplace */
1061          0,                     /* src_mask */
1062          0xffff,                /* dst_mask */
1063          FALSE),                /* pcrel_offset */
1064
1065   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1066   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1067   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1068          16,                    /* rightshift */
1069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1070          16,                    /* bitsize */
1071          FALSE,                 /* pc_relative */
1072          0,                     /* bitpos */
1073          complain_overflow_signed, /* complain_on_overflow */
1074          ppc64_elf_unhandled_reloc, /* special_function */
1075          "R_PPC64_PLTGOT16_HI", /* name */
1076          FALSE,                 /* partial_inplace */
1077          0,                     /* src_mask */
1078          0xffff,                /* dst_mask */
1079          FALSE),                /* pcrel_offset */
1080
1081   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1082      1 if the contents of the low 16 bits, treated as a signed number,
1083      is negative.  */
1084   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1085   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1086          16,                    /* rightshift */
1087          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1088          16,                    /* bitsize */
1089          FALSE,                 /* pc_relative */
1090          0,                     /* bitpos */
1091          complain_overflow_signed, /* complain_on_overflow */
1092          ppc64_elf_unhandled_reloc, /* special_function */
1093          "R_PPC64_PLTGOT16_HA", /* name */
1094          FALSE,                 /* partial_inplace */
1095          0,                     /* src_mask */
1096          0xffff,                /* dst_mask */
1097          FALSE),                /* pcrel_offset */
1098
1099   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1100   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1101          0,                     /* rightshift */
1102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1103          16,                    /* bitsize */
1104          FALSE,                 /* pc_relative */
1105          0,                     /* bitpos */
1106          complain_overflow_signed, /* complain_on_overflow */
1107          bfd_elf_generic_reloc, /* special_function */
1108          "R_PPC64_ADDR16_DS",   /* name */
1109          FALSE,                 /* partial_inplace */
1110          0,                     /* src_mask */
1111          0xfffc,                /* dst_mask */
1112          FALSE),                /* pcrel_offset */
1113
1114   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1115   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1116          0,                     /* rightshift */
1117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1118          16,                    /* bitsize */
1119          FALSE,                 /* pc_relative */
1120          0,                     /* bitpos */
1121          complain_overflow_dont,/* complain_on_overflow */
1122          bfd_elf_generic_reloc, /* special_function */
1123          "R_PPC64_ADDR16_LO_DS",/* name */
1124          FALSE,                 /* partial_inplace */
1125          0,                     /* src_mask */
1126          0xfffc,                /* dst_mask */
1127          FALSE),                /* pcrel_offset */
1128
1129   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1130   HOWTO (R_PPC64_GOT16_DS,      /* type */
1131          0,                     /* rightshift */
1132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1133          16,                    /* bitsize */
1134          FALSE,                 /* pc_relative */
1135          0,                     /* bitpos */
1136          complain_overflow_signed, /* complain_on_overflow */
1137          ppc64_elf_unhandled_reloc, /* special_function */
1138          "R_PPC64_GOT16_DS",    /* name */
1139          FALSE,                 /* partial_inplace */
1140          0,                     /* src_mask */
1141          0xfffc,                /* dst_mask */
1142          FALSE),                /* pcrel_offset */
1143
1144   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1145   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1146          0,                     /* rightshift */
1147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          16,                    /* bitsize */
1149          FALSE,                 /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont, /* complain_on_overflow */
1152          ppc64_elf_unhandled_reloc, /* special_function */
1153          "R_PPC64_GOT16_LO_DS", /* name */
1154          FALSE,                 /* partial_inplace */
1155          0,                     /* src_mask */
1156          0xfffc,                /* dst_mask */
1157          FALSE),                /* pcrel_offset */
1158
1159   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1160   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1161          0,                     /* rightshift */
1162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1163          16,                    /* bitsize */
1164          FALSE,                 /* pc_relative */
1165          0,                     /* bitpos */
1166          complain_overflow_dont, /* complain_on_overflow */
1167          ppc64_elf_unhandled_reloc, /* special_function */
1168          "R_PPC64_PLT16_LO_DS", /* name */
1169          FALSE,                 /* partial_inplace */
1170          0,                     /* src_mask */
1171          0xfffc,                /* dst_mask */
1172          FALSE),                /* pcrel_offset */
1173
1174   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1175   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1176          0,                     /* rightshift */
1177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1178          16,                    /* bitsize */
1179          FALSE,                 /* pc_relative */
1180          0,                     /* bitpos */
1181          complain_overflow_signed, /* complain_on_overflow */
1182          ppc64_elf_sectoff_reloc, /* special_function */
1183          "R_PPC64_SECTOFF_DS",  /* name */
1184          FALSE,                 /* partial_inplace */
1185          0,                     /* src_mask */
1186          0xfffc,                /* dst_mask */
1187          FALSE),                /* pcrel_offset */
1188
1189   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1190   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1191          0,                     /* rightshift */
1192          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1193          16,                    /* bitsize */
1194          FALSE,                 /* pc_relative */
1195          0,                     /* bitpos */
1196          complain_overflow_dont, /* complain_on_overflow */
1197          ppc64_elf_sectoff_reloc, /* special_function */
1198          "R_PPC64_SECTOFF_LO_DS",/* name */
1199          FALSE,                 /* partial_inplace */
1200          0,                     /* src_mask */
1201          0xfffc,                /* dst_mask */
1202          FALSE),                /* pcrel_offset */
1203
1204   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1205   HOWTO (R_PPC64_TOC16_DS,      /* type */
1206          0,                     /* rightshift */
1207          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1208          16,                    /* bitsize */
1209          FALSE,                 /* pc_relative */
1210          0,                     /* bitpos */
1211          complain_overflow_signed, /* complain_on_overflow */
1212          ppc64_elf_toc_reloc,   /* special_function */
1213          "R_PPC64_TOC16_DS",    /* name */
1214          FALSE,                 /* partial_inplace */
1215          0,                     /* src_mask */
1216          0xfffc,                /* dst_mask */
1217          FALSE),                /* pcrel_offset */
1218
1219   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1220   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1221          0,                     /* rightshift */
1222          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1223          16,                    /* bitsize */
1224          FALSE,                 /* pc_relative */
1225          0,                     /* bitpos */
1226          complain_overflow_dont, /* complain_on_overflow */
1227          ppc64_elf_toc_reloc,   /* special_function */
1228          "R_PPC64_TOC16_LO_DS", /* name */
1229          FALSE,                 /* partial_inplace */
1230          0,                     /* src_mask */
1231          0xfffc,                /* dst_mask */
1232          FALSE),                /* pcrel_offset */
1233
1234   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1235   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1236   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_signed, /* complain_on_overflow */
1243          ppc64_elf_unhandled_reloc, /* special_function */
1244          "R_PPC64_PLTGOT16_DS", /* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1251   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1252   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1253          0,                     /* rightshift */
1254          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1255          16,                    /* bitsize */
1256          FALSE,                 /* pc_relative */
1257          0,                     /* bitpos */
1258          complain_overflow_dont, /* complain_on_overflow */
1259          ppc64_elf_unhandled_reloc, /* special_function */
1260          "R_PPC64_PLTGOT16_LO_DS",/* name */
1261          FALSE,                 /* partial_inplace */
1262          0,                     /* src_mask */
1263          0xfffc,                /* dst_mask */
1264          FALSE),                /* pcrel_offset */
1265
1266   /* Marker relocs for TLS.  */
1267   HOWTO (R_PPC64_TLS,
1268          0,                     /* rightshift */
1269          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1270          32,                    /* bitsize */
1271          FALSE,                 /* pc_relative */
1272          0,                     /* bitpos */
1273          complain_overflow_dont, /* complain_on_overflow */
1274          bfd_elf_generic_reloc, /* special_function */
1275          "R_PPC64_TLS",         /* name */
1276          FALSE,                 /* partial_inplace */
1277          0,                     /* src_mask */
1278          0,                     /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   HOWTO (R_PPC64_TLSGD,
1282          0,                     /* rightshift */
1283          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1284          32,                    /* bitsize */
1285          FALSE,                 /* pc_relative */
1286          0,                     /* bitpos */
1287          complain_overflow_dont, /* complain_on_overflow */
1288          bfd_elf_generic_reloc, /* special_function */
1289          "R_PPC64_TLSGD",       /* name */
1290          FALSE,                 /* partial_inplace */
1291          0,                     /* src_mask */
1292          0,                     /* dst_mask */
1293          FALSE),                /* pcrel_offset */
1294
1295   HOWTO (R_PPC64_TLSLD,
1296          0,                     /* rightshift */
1297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1298          32,                    /* bitsize */
1299          FALSE,                 /* pc_relative */
1300          0,                     /* bitpos */
1301          complain_overflow_dont, /* complain_on_overflow */
1302          bfd_elf_generic_reloc, /* special_function */
1303          "R_PPC64_TLSLD",       /* name */
1304          FALSE,                 /* partial_inplace */
1305          0,                     /* src_mask */
1306          0,                     /* dst_mask */
1307          FALSE),                /* pcrel_offset */
1308
1309   HOWTO (R_PPC64_TOCSAVE,
1310          0,                     /* rightshift */
1311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1312          32,                    /* bitsize */
1313          FALSE,                 /* pc_relative */
1314          0,                     /* bitpos */
1315          complain_overflow_dont, /* complain_on_overflow */
1316          bfd_elf_generic_reloc, /* special_function */
1317          "R_PPC64_TOCSAVE",     /* name */
1318          FALSE,                 /* partial_inplace */
1319          0,                     /* src_mask */
1320          0,                     /* dst_mask */
1321          FALSE),                /* pcrel_offset */
1322
1323   /* Computes the load module index of the load module that contains the
1324      definition of its TLS sym.  */
1325   HOWTO (R_PPC64_DTPMOD64,
1326          0,                     /* rightshift */
1327          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1328          64,                    /* bitsize */
1329          FALSE,                 /* pc_relative */
1330          0,                     /* bitpos */
1331          complain_overflow_dont, /* complain_on_overflow */
1332          ppc64_elf_unhandled_reloc, /* special_function */
1333          "R_PPC64_DTPMOD64",    /* name */
1334          FALSE,                 /* partial_inplace */
1335          0,                     /* src_mask */
1336          ONES (64),             /* dst_mask */
1337          FALSE),                /* pcrel_offset */
1338
1339   /* Computes a dtv-relative displacement, the difference between the value
1340      of sym+add and the base address of the thread-local storage block that
1341      contains the definition of sym, minus 0x8000.  */
1342   HOWTO (R_PPC64_DTPREL64,
1343          0,                     /* rightshift */
1344          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          64,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_dont, /* complain_on_overflow */
1349          ppc64_elf_unhandled_reloc, /* special_function */
1350          "R_PPC64_DTPREL64",    /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          ONES (64),             /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* A 16 bit dtprel reloc.  */
1357   HOWTO (R_PPC64_DTPREL16,
1358          0,                     /* rightshift */
1359          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          16,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_signed, /* complain_on_overflow */
1364          ppc64_elf_unhandled_reloc, /* special_function */
1365          "R_PPC64_DTPREL16",    /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0xffff,                /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   /* Like DTPREL16, but no overflow.  */
1372   HOWTO (R_PPC64_DTPREL16_LO,
1373          0,                     /* rightshift */
1374          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1375          16,                    /* bitsize */
1376          FALSE,                 /* pc_relative */
1377          0,                     /* bitpos */
1378          complain_overflow_dont, /* complain_on_overflow */
1379          ppc64_elf_unhandled_reloc, /* special_function */
1380          "R_PPC64_DTPREL16_LO", /* name */
1381          FALSE,                 /* partial_inplace */
1382          0,                     /* src_mask */
1383          0xffff,                /* dst_mask */
1384          FALSE),                /* pcrel_offset */
1385
1386   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1387   HOWTO (R_PPC64_DTPREL16_HI,
1388          16,                    /* rightshift */
1389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          16,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_signed, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPREL16_HI", /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          0xffff,                /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1402   HOWTO (R_PPC64_DTPREL16_HA,
1403          16,                    /* rightshift */
1404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          16,                    /* bitsize */
1406          FALSE,                 /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_signed, /* complain_on_overflow */
1409          ppc64_elf_unhandled_reloc, /* special_function */
1410          "R_PPC64_DTPREL16_HA", /* name */
1411          FALSE,                 /* partial_inplace */
1412          0,                     /* src_mask */
1413          0xffff,                /* dst_mask */
1414          FALSE),                /* pcrel_offset */
1415
1416   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1417   HOWTO (R_PPC64_DTPREL16_HIGHER,
1418          32,                    /* rightshift */
1419          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          16,                    /* bitsize */
1421          FALSE,                 /* pc_relative */
1422          0,                     /* bitpos */
1423          complain_overflow_dont, /* complain_on_overflow */
1424          ppc64_elf_unhandled_reloc, /* special_function */
1425          "R_PPC64_DTPREL16_HIGHER", /* name */
1426          FALSE,                 /* partial_inplace */
1427          0,                     /* src_mask */
1428          0xffff,                /* dst_mask */
1429          FALSE),                /* pcrel_offset */
1430
1431   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1432   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1433          32,                    /* rightshift */
1434          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          16,                    /* bitsize */
1436          FALSE,                 /* pc_relative */
1437          0,                     /* bitpos */
1438          complain_overflow_dont, /* complain_on_overflow */
1439          ppc64_elf_unhandled_reloc, /* special_function */
1440          "R_PPC64_DTPREL16_HIGHERA", /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0xffff,                /* dst_mask */
1444          FALSE),                /* pcrel_offset */
1445
1446   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1447   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1448          48,                    /* rightshift */
1449          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1450          16,                    /* bitsize */
1451          FALSE,                 /* pc_relative */
1452          0,                     /* bitpos */
1453          complain_overflow_dont, /* complain_on_overflow */
1454          ppc64_elf_unhandled_reloc, /* special_function */
1455          "R_PPC64_DTPREL16_HIGHEST", /* name */
1456          FALSE,                 /* partial_inplace */
1457          0,                     /* src_mask */
1458          0xffff,                /* dst_mask */
1459          FALSE),                /* pcrel_offset */
1460
1461   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1462   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1463          48,                    /* rightshift */
1464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          16,                    /* bitsize */
1466          FALSE,                 /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_dont, /* complain_on_overflow */
1469          ppc64_elf_unhandled_reloc, /* special_function */
1470          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1471          FALSE,                 /* partial_inplace */
1472          0,                     /* src_mask */
1473          0xffff,                /* dst_mask */
1474          FALSE),                /* pcrel_offset */
1475
1476   /* Like DTPREL16, but for insns with a DS field.  */
1477   HOWTO (R_PPC64_DTPREL16_DS,
1478          0,                     /* rightshift */
1479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1480          16,                    /* bitsize */
1481          FALSE,                 /* pc_relative */
1482          0,                     /* bitpos */
1483          complain_overflow_signed, /* complain_on_overflow */
1484          ppc64_elf_unhandled_reloc, /* special_function */
1485          "R_PPC64_DTPREL16_DS", /* name */
1486          FALSE,                 /* partial_inplace */
1487          0,                     /* src_mask */
1488          0xfffc,                /* dst_mask */
1489          FALSE),                /* pcrel_offset */
1490
1491   /* Like DTPREL16_DS, but no overflow.  */
1492   HOWTO (R_PPC64_DTPREL16_LO_DS,
1493          0,                     /* rightshift */
1494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          16,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          ppc64_elf_unhandled_reloc, /* special_function */
1500          "R_PPC64_DTPREL16_LO_DS", /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          0xfffc,                /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* Computes a tp-relative displacement, the difference between the value of
1507      sym+add and the value of the thread pointer (r13).  */
1508   HOWTO (R_PPC64_TPREL64,
1509          0,                     /* rightshift */
1510          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1511          64,                    /* bitsize */
1512          FALSE,                 /* pc_relative */
1513          0,                     /* bitpos */
1514          complain_overflow_dont, /* complain_on_overflow */
1515          ppc64_elf_unhandled_reloc, /* special_function */
1516          "R_PPC64_TPREL64",     /* name */
1517          FALSE,                 /* partial_inplace */
1518          0,                     /* src_mask */
1519          ONES (64),             /* dst_mask */
1520          FALSE),                /* pcrel_offset */
1521
1522   /* A 16 bit tprel reloc.  */
1523   HOWTO (R_PPC64_TPREL16,
1524          0,                     /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          FALSE,                 /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_signed, /* complain_on_overflow */
1530          ppc64_elf_unhandled_reloc, /* special_function */
1531          "R_PPC64_TPREL16",     /* name */
1532          FALSE,                 /* partial_inplace */
1533          0,                     /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Like TPREL16, but no overflow.  */
1538   HOWTO (R_PPC64_TPREL16_LO,
1539          0,                     /* rightshift */
1540          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          16,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_dont, /* complain_on_overflow */
1545          ppc64_elf_unhandled_reloc, /* special_function */
1546          "R_PPC64_TPREL16_LO",  /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          0xffff,                /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1553   HOWTO (R_PPC64_TPREL16_HI,
1554          16,                    /* rightshift */
1555          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1556          16,                    /* bitsize */
1557          FALSE,                 /* pc_relative */
1558          0,                     /* bitpos */
1559          complain_overflow_signed, /* complain_on_overflow */
1560          ppc64_elf_unhandled_reloc, /* special_function */
1561          "R_PPC64_TPREL16_HI",  /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0xffff,                /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1568   HOWTO (R_PPC64_TPREL16_HA,
1569          16,                    /* rightshift */
1570          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1571          16,                    /* bitsize */
1572          FALSE,                 /* pc_relative */
1573          0,                     /* bitpos */
1574          complain_overflow_signed, /* complain_on_overflow */
1575          ppc64_elf_unhandled_reloc, /* special_function */
1576          "R_PPC64_TPREL16_HA",  /* name */
1577          FALSE,                 /* partial_inplace */
1578          0,                     /* src_mask */
1579          0xffff,                /* dst_mask */
1580          FALSE),                /* pcrel_offset */
1581
1582   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1583   HOWTO (R_PPC64_TPREL16_HIGHER,
1584          32,                    /* rightshift */
1585          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          16,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_dont, /* complain_on_overflow */
1590          ppc64_elf_unhandled_reloc, /* special_function */
1591          "R_PPC64_TPREL16_HIGHER",      /* name */
1592          FALSE,                 /* partial_inplace */
1593          0,                     /* src_mask */
1594          0xffff,                /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596
1597   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1598   HOWTO (R_PPC64_TPREL16_HIGHERA,
1599          32,                    /* rightshift */
1600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1601          16,                    /* bitsize */
1602          FALSE,                 /* pc_relative */
1603          0,                     /* bitpos */
1604          complain_overflow_dont, /* complain_on_overflow */
1605          ppc64_elf_unhandled_reloc, /* special_function */
1606          "R_PPC64_TPREL16_HIGHERA", /* name */
1607          FALSE,                 /* partial_inplace */
1608          0,                     /* src_mask */
1609          0xffff,                /* dst_mask */
1610          FALSE),                /* pcrel_offset */
1611
1612   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1613   HOWTO (R_PPC64_TPREL16_HIGHEST,
1614          48,                    /* rightshift */
1615          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1616          16,                    /* bitsize */
1617          FALSE,                 /* pc_relative */
1618          0,                     /* bitpos */
1619          complain_overflow_dont, /* complain_on_overflow */
1620          ppc64_elf_unhandled_reloc, /* special_function */
1621          "R_PPC64_TPREL16_HIGHEST", /* name */
1622          FALSE,                 /* partial_inplace */
1623          0,                     /* src_mask */
1624          0xffff,                /* dst_mask */
1625          FALSE),                /* pcrel_offset */
1626
1627   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1628   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1629          48,                    /* rightshift */
1630          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1631          16,                    /* bitsize */
1632          FALSE,                 /* pc_relative */
1633          0,                     /* bitpos */
1634          complain_overflow_dont, /* complain_on_overflow */
1635          ppc64_elf_unhandled_reloc, /* special_function */
1636          "R_PPC64_TPREL16_HIGHESTA", /* name */
1637          FALSE,                 /* partial_inplace */
1638          0,                     /* src_mask */
1639          0xffff,                /* dst_mask */
1640          FALSE),                /* pcrel_offset */
1641
1642   /* Like TPREL16, but for insns with a DS field.  */
1643   HOWTO (R_PPC64_TPREL16_DS,
1644          0,                     /* rightshift */
1645          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1646          16,                    /* bitsize */
1647          FALSE,                 /* pc_relative */
1648          0,                     /* bitpos */
1649          complain_overflow_signed, /* complain_on_overflow */
1650          ppc64_elf_unhandled_reloc, /* special_function */
1651          "R_PPC64_TPREL16_DS",  /* name */
1652          FALSE,                 /* partial_inplace */
1653          0,                     /* src_mask */
1654          0xfffc,                /* dst_mask */
1655          FALSE),                /* pcrel_offset */
1656
1657   /* Like TPREL16_DS, but no overflow.  */
1658   HOWTO (R_PPC64_TPREL16_LO_DS,
1659          0,                     /* rightshift */
1660          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1661          16,                    /* bitsize */
1662          FALSE,                 /* pc_relative */
1663          0,                     /* bitpos */
1664          complain_overflow_dont, /* complain_on_overflow */
1665          ppc64_elf_unhandled_reloc, /* special_function */
1666          "R_PPC64_TPREL16_LO_DS", /* name */
1667          FALSE,                 /* partial_inplace */
1668          0,                     /* src_mask */
1669          0xfffc,                /* dst_mask */
1670          FALSE),                /* pcrel_offset */
1671
1672   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1673      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1674      to the first entry relative to the TOC base (r2).  */
1675   HOWTO (R_PPC64_GOT_TLSGD16,
1676          0,                     /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_signed, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_GOT_TLSGD16", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like GOT_TLSGD16, but no overflow.  */
1690   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1691          0,                     /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_dont, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_GOT_TLSGD16_LO", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1705   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1706          16,                    /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_GOT_TLSGD16_HI", /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xffff,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1720   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1721          16,                    /* rightshift */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1723          16,                    /* bitsize */
1724          FALSE,                 /* pc_relative */
1725          0,                     /* bitpos */
1726          complain_overflow_signed, /* complain_on_overflow */
1727          ppc64_elf_unhandled_reloc, /* special_function */
1728          "R_PPC64_GOT_TLSGD16_HA", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xffff,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735      with values (sym+add)@dtpmod and zero, and computes the offset to the
1736      first entry relative to the TOC base (r2).  */
1737   HOWTO (R_PPC64_GOT_TLSLD16,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_signed, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSLD16", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSLD16, but no overflow.  */
1752   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_dont, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSLD16_LO", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1768          16,                    /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSLD16_HI", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1782   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1783          16,                    /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSLD16_HA", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1797      the offset to the entry relative to the TOC base (r2).  */
1798   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1799          0,                     /* rightshift */
1800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1801          16,                    /* bitsize */
1802          FALSE,                 /* pc_relative */
1803          0,                     /* bitpos */
1804          complain_overflow_signed, /* complain_on_overflow */
1805          ppc64_elf_unhandled_reloc, /* special_function */
1806          "R_PPC64_GOT_DTPREL16_DS", /* name */
1807          FALSE,                 /* partial_inplace */
1808          0,                     /* src_mask */
1809          0xfffc,                /* dst_mask */
1810          FALSE),                /* pcrel_offset */
1811
1812   /* Like GOT_DTPREL16_DS, but no overflow.  */
1813   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1814          0,                     /* rightshift */
1815          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1816          16,                    /* bitsize */
1817          FALSE,                 /* pc_relative */
1818          0,                     /* bitpos */
1819          complain_overflow_dont, /* complain_on_overflow */
1820          ppc64_elf_unhandled_reloc, /* special_function */
1821          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1822          FALSE,                 /* partial_inplace */
1823          0,                     /* src_mask */
1824          0xfffc,                /* dst_mask */
1825          FALSE),                /* pcrel_offset */
1826
1827   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1828   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1829          16,                    /* rightshift */
1830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1831          16,                    /* bitsize */
1832          FALSE,                 /* pc_relative */
1833          0,                     /* bitpos */
1834          complain_overflow_signed, /* complain_on_overflow */
1835          ppc64_elf_unhandled_reloc, /* special_function */
1836          "R_PPC64_GOT_DTPREL16_HI", /* name */
1837          FALSE,                 /* partial_inplace */
1838          0,                     /* src_mask */
1839          0xffff,                /* dst_mask */
1840          FALSE),                /* pcrel_offset */
1841
1842   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1843   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1844          16,                    /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_DTPREL16_HA", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xffff,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1858      offset to the entry relative to the TOC base (r2).  */
1859   HOWTO (R_PPC64_GOT_TPREL16_DS,
1860          0,                     /* rightshift */
1861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1862          16,                    /* bitsize */
1863          FALSE,                 /* pc_relative */
1864          0,                     /* bitpos */
1865          complain_overflow_signed, /* complain_on_overflow */
1866          ppc64_elf_unhandled_reloc, /* special_function */
1867          "R_PPC64_GOT_TPREL16_DS", /* name */
1868          FALSE,                 /* partial_inplace */
1869          0,                     /* src_mask */
1870          0xfffc,                /* dst_mask */
1871          FALSE),                /* pcrel_offset */
1872
1873   /* Like GOT_TPREL16_DS, but no overflow.  */
1874   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1875          0,                     /* rightshift */
1876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1877          16,                    /* bitsize */
1878          FALSE,                 /* pc_relative */
1879          0,                     /* bitpos */
1880          complain_overflow_dont, /* complain_on_overflow */
1881          ppc64_elf_unhandled_reloc, /* special_function */
1882          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1883          FALSE,                 /* partial_inplace */
1884          0,                     /* src_mask */
1885          0xfffc,                /* dst_mask */
1886          FALSE),                /* pcrel_offset */
1887
1888   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1889   HOWTO (R_PPC64_GOT_TPREL16_HI,
1890          16,                    /* rightshift */
1891          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1892          16,                    /* bitsize */
1893          FALSE,                 /* pc_relative */
1894          0,                     /* bitpos */
1895          complain_overflow_signed, /* complain_on_overflow */
1896          ppc64_elf_unhandled_reloc, /* special_function */
1897          "R_PPC64_GOT_TPREL16_HI", /* name */
1898          FALSE,                 /* partial_inplace */
1899          0,                     /* src_mask */
1900          0xffff,                /* dst_mask */
1901          FALSE),                /* pcrel_offset */
1902
1903   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1904   HOWTO (R_PPC64_GOT_TPREL16_HA,
1905          16,                    /* rightshift */
1906          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1907          16,                    /* bitsize */
1908          FALSE,                 /* pc_relative */
1909          0,                     /* bitpos */
1910          complain_overflow_signed, /* complain_on_overflow */
1911          ppc64_elf_unhandled_reloc, /* special_function */
1912          "R_PPC64_GOT_TPREL16_HA", /* name */
1913          FALSE,                 /* partial_inplace */
1914          0,                     /* src_mask */
1915          0xffff,                /* dst_mask */
1916          FALSE),                /* pcrel_offset */
1917
1918   HOWTO (R_PPC64_JMP_IREL,      /* type */
1919          0,                     /* rightshift */
1920          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1921          0,                     /* bitsize */
1922          FALSE,                 /* pc_relative */
1923          0,                     /* bitpos */
1924          complain_overflow_dont, /* complain_on_overflow */
1925          ppc64_elf_unhandled_reloc, /* special_function */
1926          "R_PPC64_JMP_IREL",    /* name */
1927          FALSE,                 /* partial_inplace */
1928          0,                     /* src_mask */
1929          0,                     /* dst_mask */
1930          FALSE),                /* pcrel_offset */
1931
1932   HOWTO (R_PPC64_IRELATIVE,     /* type */
1933          0,                     /* rightshift */
1934          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935          64,                    /* bitsize */
1936          FALSE,                 /* pc_relative */
1937          0,                     /* bitpos */
1938          complain_overflow_dont, /* complain_on_overflow */
1939          bfd_elf_generic_reloc, /* special_function */
1940          "R_PPC64_IRELATIVE",   /* name */
1941          FALSE,                 /* partial_inplace */
1942          0,                     /* src_mask */
1943          ONES (64),             /* dst_mask */
1944          FALSE),                /* pcrel_offset */
1945
1946   /* A 16 bit relative relocation.  */
1947   HOWTO (R_PPC64_REL16,         /* type */
1948          0,                     /* rightshift */
1949          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1950          16,                    /* bitsize */
1951          TRUE,                  /* pc_relative */
1952          0,                     /* bitpos */
1953          complain_overflow_signed, /* complain_on_overflow */
1954          bfd_elf_generic_reloc, /* special_function */
1955          "R_PPC64_REL16",       /* name */
1956          FALSE,                 /* partial_inplace */
1957          0,                     /* src_mask */
1958          0xffff,                /* dst_mask */
1959          TRUE),                 /* pcrel_offset */
1960
1961   /* A 16 bit relative relocation without overflow.  */
1962   HOWTO (R_PPC64_REL16_LO,      /* type */
1963          0,                     /* rightshift */
1964          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1965          16,                    /* bitsize */
1966          TRUE,                  /* pc_relative */
1967          0,                     /* bitpos */
1968          complain_overflow_dont,/* complain_on_overflow */
1969          bfd_elf_generic_reloc, /* special_function */
1970          "R_PPC64_REL16_LO",    /* name */
1971          FALSE,                 /* partial_inplace */
1972          0,                     /* src_mask */
1973          0xffff,                /* dst_mask */
1974          TRUE),                 /* pcrel_offset */
1975
1976   /* The high order 16 bits of a relative address.  */
1977   HOWTO (R_PPC64_REL16_HI,      /* type */
1978          16,                    /* rightshift */
1979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1980          16,                    /* bitsize */
1981          TRUE,                  /* pc_relative */
1982          0,                     /* bitpos */
1983          complain_overflow_signed, /* complain_on_overflow */
1984          bfd_elf_generic_reloc, /* special_function */
1985          "R_PPC64_REL16_HI",    /* name */
1986          FALSE,                 /* partial_inplace */
1987          0,                     /* src_mask */
1988          0xffff,                /* dst_mask */
1989          TRUE),                 /* pcrel_offset */
1990
1991   /* The high order 16 bits of a relative address, plus 1 if the contents of
1992      the low 16 bits, treated as a signed number, is negative.  */
1993   HOWTO (R_PPC64_REL16_HA,      /* type */
1994          16,                    /* rightshift */
1995          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1996          16,                    /* bitsize */
1997          TRUE,                  /* pc_relative */
1998          0,                     /* bitpos */
1999          complain_overflow_signed, /* complain_on_overflow */
2000          ppc64_elf_ha_reloc,    /* special_function */
2001          "R_PPC64_REL16_HA",    /* name */
2002          FALSE,                 /* partial_inplace */
2003          0,                     /* src_mask */
2004          0xffff,                /* dst_mask */
2005          TRUE),                 /* pcrel_offset */
2006
2007   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2008   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2009          16,                    /* rightshift */
2010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2011          16,                    /* bitsize */
2012          FALSE,                 /* pc_relative */
2013          0,                     /* bitpos */
2014          complain_overflow_dont, /* complain_on_overflow */
2015          bfd_elf_generic_reloc, /* special_function */
2016          "R_PPC64_ADDR16_HIGH", /* name */
2017          FALSE,                 /* partial_inplace */
2018          0,                     /* src_mask */
2019          0xffff,                /* dst_mask */
2020          FALSE),                /* pcrel_offset */
2021
2022   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2023   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2024          16,                    /* rightshift */
2025          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2026          16,                    /* bitsize */
2027          FALSE,                 /* pc_relative */
2028          0,                     /* bitpos */
2029          complain_overflow_dont, /* complain_on_overflow */
2030          ppc64_elf_ha_reloc,    /* special_function */
2031          "R_PPC64_ADDR16_HIGHA",        /* name */
2032          FALSE,                 /* partial_inplace */
2033          0,                     /* src_mask */
2034          0xffff,                /* dst_mask */
2035          FALSE),                /* pcrel_offset */
2036
2037   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2038   HOWTO (R_PPC64_DTPREL16_HIGH,
2039          16,                    /* rightshift */
2040          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2041          16,                    /* bitsize */
2042          FALSE,                 /* pc_relative */
2043          0,                     /* bitpos */
2044          complain_overflow_dont, /* complain_on_overflow */
2045          ppc64_elf_unhandled_reloc, /* special_function */
2046          "R_PPC64_DTPREL16_HIGH", /* name */
2047          FALSE,                 /* partial_inplace */
2048          0,                     /* src_mask */
2049          0xffff,                /* dst_mask */
2050          FALSE),                /* pcrel_offset */
2051
2052   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2053   HOWTO (R_PPC64_DTPREL16_HIGHA,
2054          16,                    /* rightshift */
2055          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2056          16,                    /* bitsize */
2057          FALSE,                 /* pc_relative */
2058          0,                     /* bitpos */
2059          complain_overflow_dont, /* complain_on_overflow */
2060          ppc64_elf_unhandled_reloc, /* special_function */
2061          "R_PPC64_DTPREL16_HIGHA", /* name */
2062          FALSE,                 /* partial_inplace */
2063          0,                     /* src_mask */
2064          0xffff,                /* dst_mask */
2065          FALSE),                /* pcrel_offset */
2066
2067   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2068   HOWTO (R_PPC64_TPREL16_HIGH,
2069          16,                    /* rightshift */
2070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2071          16,                    /* bitsize */
2072          FALSE,                 /* pc_relative */
2073          0,                     /* bitpos */
2074          complain_overflow_dont, /* complain_on_overflow */
2075          ppc64_elf_unhandled_reloc, /* special_function */
2076          "R_PPC64_TPREL16_HIGH",        /* name */
2077          FALSE,                 /* partial_inplace */
2078          0,                     /* src_mask */
2079          0xffff,                /* dst_mask */
2080          FALSE),                /* pcrel_offset */
2081
2082   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2083   HOWTO (R_PPC64_TPREL16_HIGHA,
2084          16,                    /* rightshift */
2085          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2086          16,                    /* bitsize */
2087          FALSE,                 /* pc_relative */
2088          0,                     /* bitpos */
2089          complain_overflow_dont, /* complain_on_overflow */
2090          ppc64_elf_unhandled_reloc, /* special_function */
2091          "R_PPC64_TPREL16_HIGHA",       /* name */
2092          FALSE,                 /* partial_inplace */
2093          0,                     /* src_mask */
2094          0xffff,                /* dst_mask */
2095          FALSE),                /* pcrel_offset */
2096
2097   /* Like ADDR64, but use local entry point of function.  */
2098   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2099          0,                     /* rightshift */
2100          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2101          64,                    /* bitsize */
2102          FALSE,                 /* pc_relative */
2103          0,                     /* bitpos */
2104          complain_overflow_dont, /* complain_on_overflow */
2105          bfd_elf_generic_reloc, /* special_function */
2106          "R_PPC64_ADDR64_LOCAL", /* name */
2107          FALSE,                 /* partial_inplace */
2108          0,                     /* src_mask */
2109          ONES (64),             /* dst_mask */
2110          FALSE),                /* pcrel_offset */
2111
2112   /* GNU extension to record C++ vtable hierarchy.  */
2113   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2114          0,                     /* rightshift */
2115          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2116          0,                     /* bitsize */
2117          FALSE,                 /* pc_relative */
2118          0,                     /* bitpos */
2119          complain_overflow_dont, /* complain_on_overflow */
2120          NULL,                  /* special_function */
2121          "R_PPC64_GNU_VTINHERIT", /* name */
2122          FALSE,                 /* partial_inplace */
2123          0,                     /* src_mask */
2124          0,                     /* dst_mask */
2125          FALSE),                /* pcrel_offset */
2126
2127   /* GNU extension to record C++ vtable member usage.  */
2128   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2129          0,                     /* rightshift */
2130          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2131          0,                     /* bitsize */
2132          FALSE,                 /* pc_relative */
2133          0,                     /* bitpos */
2134          complain_overflow_dont, /* complain_on_overflow */
2135          NULL,                  /* special_function */
2136          "R_PPC64_GNU_VTENTRY", /* name */
2137          FALSE,                 /* partial_inplace */
2138          0,                     /* src_mask */
2139          0,                     /* dst_mask */
2140          FALSE),                /* pcrel_offset */
2141 };
2142
2143 \f
2144 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2145    be done.  */
2146
2147 static void
2148 ppc_howto_init (void)
2149 {
2150   unsigned int i, type;
2151
2152   for (i = 0;
2153        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2154        i++)
2155     {
2156       type = ppc64_elf_howto_raw[i].type;
2157       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2158                           / sizeof (ppc64_elf_howto_table[0])));
2159       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2160     }
2161 }
2162
2163 static reloc_howto_type *
2164 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2165                              bfd_reloc_code_real_type code)
2166 {
2167   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2168
2169   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2170     /* Initialize howto table if needed.  */
2171     ppc_howto_init ();
2172
2173   switch (code)
2174     {
2175     default:
2176       return NULL;
2177
2178     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2179       break;
2180     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2181       break;
2182     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2183       break;
2184     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2185       break;
2186     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2187       break;
2188     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2189       break;
2190     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2191       break;
2192     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2193       break;
2194     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2195       break;
2196     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2197       break;
2198     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2199       break;
2200     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2201       break;
2202     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2203       break;
2204     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2205       break;
2206     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2207       break;
2208     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2209       break;
2210     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2211       break;
2212     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2213       break;
2214     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2215       break;
2216     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2217       break;
2218     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2219       break;
2220     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2221       break;
2222     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2223       break;
2224     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2225       break;
2226     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2227       break;
2228     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2229       break;
2230     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2231       break;
2232     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2233       break;
2234     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2235       break;
2236     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2237       break;
2238     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2241       break;
2242     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2243       break;
2244     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2245       break;
2246     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2247       break;
2248     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2249       break;
2250     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2251       break;
2252     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2253       break;
2254     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2255       break;
2256     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2257       break;
2258     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2259       break;
2260     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2261       break;
2262     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2263       break;
2264     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2265       break;
2266     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2267       break;
2268     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2269       break;
2270     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2271       break;
2272     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2273       break;
2274     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2275       break;
2276     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2277       break;
2278     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2287       break;
2288     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2289       break;
2290     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2291       break;
2292     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2293       break;
2294     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2295       break;
2296     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2297       break;
2298     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2301       break;
2302     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2303       break;
2304     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2305       break;
2306     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2307       break;
2308     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2309       break;
2310     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2321       break;
2322     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2323       break;
2324     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2325       break;
2326     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2327       break;
2328     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2329       break;
2330     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2331       break;
2332     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2333       break;
2334     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2345       break;
2346     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2347       break;
2348     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2359       break;
2360     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2361       break;
2362     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2363       break;
2364     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2365       break;
2366     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2367       break;
2368     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2369       break;
2370     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2371       break;
2372     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2373       break;
2374     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2375       break;
2376     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2377       break;
2378     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2379       break;
2380     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2381       break;
2382     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2383       break;
2384     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2385       break;
2386     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2387       break;
2388     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2389       break;
2390     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2391       break;
2392     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2393       break;
2394     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2395       break;
2396     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2397       break;
2398     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2399       break;
2400     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2401       break;
2402     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2403       break;
2404     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2405       break;
2406     }
2407
2408   return ppc64_elf_howto_table[r];
2409 };
2410
2411 static reloc_howto_type *
2412 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2413                              const char *r_name)
2414 {
2415   unsigned int i;
2416
2417   for (i = 0;
2418        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2419        i++)
2420     if (ppc64_elf_howto_raw[i].name != NULL
2421         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2422       return &ppc64_elf_howto_raw[i];
2423
2424   return NULL;
2425 }
2426
2427 /* Set the howto pointer for a PowerPC ELF reloc.  */
2428
2429 static void
2430 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2431                          Elf_Internal_Rela *dst)
2432 {
2433   unsigned int type;
2434
2435   /* Initialize howto table if needed.  */
2436   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2437     ppc_howto_init ();
2438
2439   type = ELF64_R_TYPE (dst->r_info);
2440   if (type >= (sizeof (ppc64_elf_howto_table)
2441                / sizeof (ppc64_elf_howto_table[0])))
2442     {
2443       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2444                              abfd, (int) type);
2445       type = R_PPC64_NONE;
2446     }
2447   cache_ptr->howto = ppc64_elf_howto_table[type];
2448 }
2449
2450 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2451
2452 static bfd_reloc_status_type
2453 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2454                     void *data, asection *input_section,
2455                     bfd *output_bfd, char **error_message)
2456 {
2457   /* If this is a relocatable link (output_bfd test tells us), just
2458      call the generic function.  Any adjustment will be done at final
2459      link time.  */
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462                                   input_section, output_bfd, error_message);
2463
2464   /* Adjust the addend for sign extension of the low 16 bits.
2465      We won't actually be using the low 16 bits, so trashing them
2466      doesn't matter.  */
2467   reloc_entry->addend += 0x8000;
2468   return bfd_reloc_continue;
2469 }
2470
2471 static bfd_reloc_status_type
2472 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2473                         void *data, asection *input_section,
2474                         bfd *output_bfd, char **error_message)
2475 {
2476   if (output_bfd != NULL)
2477     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478                                   input_section, output_bfd, error_message);
2479
2480   if (strcmp (symbol->section->name, ".opd") == 0
2481       && (symbol->section->owner->flags & DYNAMIC) == 0)
2482     {
2483       bfd_vma dest = opd_entry_value (symbol->section,
2484                                       symbol->value + reloc_entry->addend,
2485                                       NULL, NULL, FALSE);
2486       if (dest != (bfd_vma) -1)
2487         reloc_entry->addend = dest - (symbol->value
2488                                       + symbol->section->output_section->vma
2489                                       + symbol->section->output_offset);
2490     }
2491   return bfd_reloc_continue;
2492 }
2493
2494 static bfd_reloc_status_type
2495 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2496                          void *data, asection *input_section,
2497                          bfd *output_bfd, char **error_message)
2498 {
2499   long insn;
2500   enum elf_ppc64_reloc_type r_type;
2501   bfd_size_type octets;
2502   /* Assume 'at' branch hints.  */
2503   bfd_boolean is_isa_v2 = TRUE;
2504
2505   /* If this is a relocatable link (output_bfd test tells us), just
2506      call the generic function.  Any adjustment will be done at final
2507      link time.  */
2508   if (output_bfd != NULL)
2509     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2510                                   input_section, output_bfd, error_message);
2511
2512   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2513   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2514   insn &= ~(0x01 << 21);
2515   r_type = reloc_entry->howto->type;
2516   if (r_type == R_PPC64_ADDR14_BRTAKEN
2517       || r_type == R_PPC64_REL14_BRTAKEN)
2518     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2519
2520   if (is_isa_v2)
2521     {
2522       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2523          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2524          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2525       if ((insn & (0x14 << 21)) == (0x04 << 21))
2526         insn |= 0x02 << 21;
2527       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2528         insn |= 0x08 << 21;
2529       else
2530         goto out;
2531     }
2532   else
2533     {
2534       bfd_vma target = 0;
2535       bfd_vma from;
2536
2537       if (!bfd_is_com_section (symbol->section))
2538         target = symbol->value;
2539       target += symbol->section->output_section->vma;
2540       target += symbol->section->output_offset;
2541       target += reloc_entry->addend;
2542
2543       from = (reloc_entry->address
2544               + input_section->output_offset
2545               + input_section->output_section->vma);
2546
2547       /* Invert 'y' bit if not the default.  */
2548       if ((bfd_signed_vma) (target - from) < 0)
2549         insn ^= 0x01 << 21;
2550     }
2551   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2552  out:
2553   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2554                                  input_section, output_bfd, error_message);
2555 }
2556
2557 static bfd_reloc_status_type
2558 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2559                          void *data, asection *input_section,
2560                          bfd *output_bfd, char **error_message)
2561 {
2562   /* If this is a relocatable link (output_bfd test tells us), just
2563      call the generic function.  Any adjustment will be done at final
2564      link time.  */
2565   if (output_bfd != NULL)
2566     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2567                                   input_section, output_bfd, error_message);
2568
2569   /* Subtract the symbol section base address.  */
2570   reloc_entry->addend -= symbol->section->output_section->vma;
2571   return bfd_reloc_continue;
2572 }
2573
2574 static bfd_reloc_status_type
2575 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2576                             void *data, asection *input_section,
2577                             bfd *output_bfd, char **error_message)
2578 {
2579   /* If this is a relocatable link (output_bfd test tells us), just
2580      call the generic function.  Any adjustment will be done at final
2581      link time.  */
2582   if (output_bfd != NULL)
2583     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2584                                   input_section, output_bfd, error_message);
2585
2586   /* Subtract the symbol section base address.  */
2587   reloc_entry->addend -= symbol->section->output_section->vma;
2588
2589   /* Adjust the addend for sign extension of the low 16 bits.  */
2590   reloc_entry->addend += 0x8000;
2591   return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                      void *data, asection *input_section,
2597                      bfd *output_bfd, char **error_message)
2598 {
2599   bfd_vma TOCstart;
2600
2601   /* If this is a relocatable link (output_bfd test tells us), just
2602      call the generic function.  Any adjustment will be done at final
2603      link time.  */
2604   if (output_bfd != NULL)
2605     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2606                                   input_section, output_bfd, error_message);
2607
2608   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2609   if (TOCstart == 0)
2610     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2611
2612   /* Subtract the TOC base address.  */
2613   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2614   return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619                         void *data, asection *input_section,
2620                         bfd *output_bfd, char **error_message)
2621 {
2622   bfd_vma TOCstart;
2623
2624   /* If this is a relocatable link (output_bfd test tells us), just
2625      call the generic function.  Any adjustment will be done at final
2626      link time.  */
2627   if (output_bfd != NULL)
2628     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2629                                   input_section, output_bfd, error_message);
2630
2631   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2632   if (TOCstart == 0)
2633     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2634
2635   /* Subtract the TOC base address.  */
2636   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2637
2638   /* Adjust the addend for sign extension of the low 16 bits.  */
2639   reloc_entry->addend += 0x8000;
2640   return bfd_reloc_continue;
2641 }
2642
2643 static bfd_reloc_status_type
2644 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2645                        void *data, asection *input_section,
2646                        bfd *output_bfd, char **error_message)
2647 {
2648   bfd_vma TOCstart;
2649   bfd_size_type octets;
2650
2651   /* If this is a relocatable link (output_bfd test tells us), just
2652      call the generic function.  Any adjustment will be done at final
2653      link time.  */
2654   if (output_bfd != NULL)
2655     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2656                                   input_section, output_bfd, error_message);
2657
2658   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2659   if (TOCstart == 0)
2660     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2661
2662   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2663   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2664   return bfd_reloc_ok;
2665 }
2666
2667 static bfd_reloc_status_type
2668 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2669                            void *data, asection *input_section,
2670                            bfd *output_bfd, char **error_message)
2671 {
2672   /* If this is a relocatable link (output_bfd test tells us), just
2673      call the generic function.  Any adjustment will be done at final
2674      link time.  */
2675   if (output_bfd != NULL)
2676     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2677                                   input_section, output_bfd, error_message);
2678
2679   if (error_message != NULL)
2680     {
2681       static char buf[60];
2682       sprintf (buf, "generic linker can't handle %s",
2683                reloc_entry->howto->name);
2684       *error_message = buf;
2685     }
2686   return bfd_reloc_dangerous;
2687 }
2688
2689 /* Track GOT entries needed for a given symbol.  We might need more
2690    than one got entry per symbol.  */
2691 struct got_entry
2692 {
2693   struct got_entry *next;
2694
2695   /* The symbol addend that we'll be placing in the GOT.  */
2696   bfd_vma addend;
2697
2698   /* Unlike other ELF targets, we use separate GOT entries for the same
2699      symbol referenced from different input files.  This is to support
2700      automatic multiple TOC/GOT sections, where the TOC base can vary
2701      from one input file to another.  After partitioning into TOC groups
2702      we merge entries within the group.
2703
2704      Point to the BFD owning this GOT entry.  */
2705   bfd *owner;
2706
2707   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2708      TLS_TPREL or TLS_DTPREL for tls entries.  */
2709   unsigned char tls_type;
2710
2711   /* Non-zero if got.ent points to real entry.  */
2712   unsigned char is_indirect;
2713
2714   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2715   union
2716     {
2717       bfd_signed_vma refcount;
2718       bfd_vma offset;
2719       struct got_entry *ent;
2720     } got;
2721 };
2722
2723 /* The same for PLT.  */
2724 struct plt_entry
2725 {
2726   struct plt_entry *next;
2727
2728   bfd_vma addend;
2729
2730   union
2731     {
2732       bfd_signed_vma refcount;
2733       bfd_vma offset;
2734     } plt;
2735 };
2736
2737 struct ppc64_elf_obj_tdata
2738 {
2739   struct elf_obj_tdata elf;
2740
2741   /* Shortcuts to dynamic linker sections.  */
2742   asection *got;
2743   asection *relgot;
2744
2745   /* Used during garbage collection.  We attach global symbols defined
2746      on removed .opd entries to this section so that the sym is removed.  */
2747   asection *deleted_section;
2748
2749   /* TLS local dynamic got entry handling.  Support for multiple GOT
2750      sections means we potentially need one of these for each input bfd.  */
2751   struct got_entry tlsld_got;
2752
2753   union {
2754     /* A copy of relocs before they are modified for --emit-relocs.  */
2755     Elf_Internal_Rela *relocs;
2756
2757     /* Section contents.  */
2758     bfd_byte *contents;
2759   } opd;
2760
2761   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2762      the reloc to be in the range -32768 to 32767.  */
2763   unsigned int has_small_toc_reloc : 1;
2764
2765   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2766      instruction not one we handle.  */
2767   unsigned int unexpected_toc_insn : 1;
2768 };
2769
2770 #define ppc64_elf_tdata(bfd) \
2771   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2772
2773 #define ppc64_tlsld_got(bfd) \
2774   (&ppc64_elf_tdata (bfd)->tlsld_got)
2775
2776 #define is_ppc64_elf(bfd) \
2777   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2778    && elf_object_id (bfd) == PPC64_ELF_DATA)
2779
2780 /* Override the generic function because we store some extras.  */
2781
2782 static bfd_boolean
2783 ppc64_elf_mkobject (bfd *abfd)
2784 {
2785   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2786                                   PPC64_ELF_DATA);
2787 }
2788
2789 /* Fix bad default arch selected for a 64 bit input bfd when the
2790    default is 32 bit.  */
2791
2792 static bfd_boolean
2793 ppc64_elf_object_p (bfd *abfd)
2794 {
2795   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2796     {
2797       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2798
2799       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2800         {
2801           /* Relies on arch after 32 bit default being 64 bit default.  */
2802           abfd->arch_info = abfd->arch_info->next;
2803           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2804         }
2805     }
2806   return TRUE;
2807 }
2808
2809 /* Support for core dump NOTE sections.  */
2810
2811 static bfd_boolean
2812 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2813 {
2814   size_t offset, size;
2815
2816   if (note->descsz != 504)
2817     return FALSE;
2818
2819   /* pr_cursig */
2820   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2821
2822   /* pr_pid */
2823   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2824
2825   /* pr_reg */
2826   offset = 112;
2827   size = 384;
2828
2829   /* Make a ".reg/999" section.  */
2830   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2831                                           size, note->descpos + offset);
2832 }
2833
2834 static bfd_boolean
2835 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2836 {
2837   if (note->descsz != 136)
2838     return FALSE;
2839
2840   elf_tdata (abfd)->core->pid
2841     = bfd_get_32 (abfd, note->descdata + 24);
2842   elf_tdata (abfd)->core->program
2843     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2844   elf_tdata (abfd)->core->command
2845     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2846
2847   return TRUE;
2848 }
2849
2850 static char *
2851 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2852                            ...)
2853 {
2854   switch (note_type)
2855     {
2856     default:
2857       return NULL;
2858
2859     case NT_PRPSINFO:
2860       {
2861         char data[136];
2862         va_list ap;
2863
2864         va_start (ap, note_type);
2865         memset (data, 0, sizeof (data));
2866         strncpy (data + 40, va_arg (ap, const char *), 16);
2867         strncpy (data + 56, va_arg (ap, const char *), 80);
2868         va_end (ap);
2869         return elfcore_write_note (abfd, buf, bufsiz,
2870                                    "CORE", note_type, data, sizeof (data));
2871       }
2872
2873     case NT_PRSTATUS:
2874       {
2875         char data[504];
2876         va_list ap;
2877         long pid;
2878         int cursig;
2879         const void *greg;
2880
2881         va_start (ap, note_type);
2882         memset (data, 0, 112);
2883         pid = va_arg (ap, long);
2884         bfd_put_32 (abfd, pid, data + 32);
2885         cursig = va_arg (ap, int);
2886         bfd_put_16 (abfd, cursig, data + 12);
2887         greg = va_arg (ap, const void *);
2888         memcpy (data + 112, greg, 384);
2889         memset (data + 496, 0, 8);
2890         va_end (ap);
2891         return elfcore_write_note (abfd, buf, bufsiz,
2892                                    "CORE", note_type, data, sizeof (data));
2893       }
2894     }
2895 }
2896
2897 /* Add extra PPC sections.  */
2898
2899 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2900 {
2901   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2902   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2903   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2906   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2907   { NULL,                     0,  0, 0,            0 }
2908 };
2909
2910 enum _ppc64_sec_type {
2911   sec_normal = 0,
2912   sec_opd = 1,
2913   sec_toc = 2
2914 };
2915
2916 struct _ppc64_elf_section_data
2917 {
2918   struct bfd_elf_section_data elf;
2919
2920   union
2921   {
2922     /* An array with one entry for each opd function descriptor.  */
2923     struct _opd_sec_data
2924     {
2925       /* Points to the function code section for local opd entries.  */
2926       asection **func_sec;
2927
2928       /* After editing .opd, adjust references to opd local syms.  */
2929       long *adjust;
2930     } opd;
2931
2932     /* An array for toc sections, indexed by offset/8.  */
2933     struct _toc_sec_data
2934     {
2935       /* Specifies the relocation symbol index used at a given toc offset.  */
2936       unsigned *symndx;
2937
2938       /* And the relocation addend.  */
2939       bfd_vma *add;
2940     } toc;
2941   } u;
2942
2943   enum _ppc64_sec_type sec_type:2;
2944
2945   /* Flag set when small branches are detected.  Used to
2946      select suitable defaults for the stub group size.  */
2947   unsigned int has_14bit_branch:1;
2948 };
2949
2950 #define ppc64_elf_section_data(sec) \
2951   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2952
2953 static bfd_boolean
2954 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2955 {
2956   if (!sec->used_by_bfd)
2957     {
2958       struct _ppc64_elf_section_data *sdata;
2959       bfd_size_type amt = sizeof (*sdata);
2960
2961       sdata = bfd_zalloc (abfd, amt);
2962       if (sdata == NULL)
2963         return FALSE;
2964       sec->used_by_bfd = sdata;
2965     }
2966
2967   return _bfd_elf_new_section_hook (abfd, sec);
2968 }
2969
2970 static struct _opd_sec_data *
2971 get_opd_info (asection * sec)
2972 {
2973   if (sec != NULL
2974       && ppc64_elf_section_data (sec) != NULL
2975       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2976     return &ppc64_elf_section_data (sec)->u.opd;
2977   return NULL;
2978 }
2979
2980 static inline int
2981 abiversion (bfd *abfd)
2982 {
2983   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2984 }
2985
2986 static inline void
2987 set_abiversion (bfd *abfd, int ver)
2988 {
2989   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2990   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2991 }
2992 \f
2993 /* Parameters for the qsort hook.  */
2994 static bfd_boolean synthetic_relocatable;
2995
2996 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2997
2998 static int
2999 compare_symbols (const void *ap, const void *bp)
3000 {
3001   const asymbol *a = * (const asymbol **) ap;
3002   const asymbol *b = * (const asymbol **) bp;
3003
3004   /* Section symbols first.  */
3005   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3006     return -1;
3007   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3008     return 1;
3009
3010   /* then .opd symbols.  */
3011   if (strcmp (a->section->name, ".opd") == 0
3012       && strcmp (b->section->name, ".opd") != 0)
3013     return -1;
3014   if (strcmp (a->section->name, ".opd") != 0
3015       && strcmp (b->section->name, ".opd") == 0)
3016     return 1;
3017
3018   /* then other code symbols.  */
3019   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3020       == (SEC_CODE | SEC_ALLOC)
3021       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3022          != (SEC_CODE | SEC_ALLOC))
3023     return -1;
3024
3025   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3026       != (SEC_CODE | SEC_ALLOC)
3027       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3028          == (SEC_CODE | SEC_ALLOC))
3029     return 1;
3030
3031   if (synthetic_relocatable)
3032     {
3033       if (a->section->id < b->section->id)
3034         return -1;
3035
3036       if (a->section->id > b->section->id)
3037         return 1;
3038     }
3039
3040   if (a->value + a->section->vma < b->value + b->section->vma)
3041     return -1;
3042
3043   if (a->value + a->section->vma > b->value + b->section->vma)
3044     return 1;
3045
3046   /* For syms with the same value, prefer strong dynamic global function
3047      syms over other syms.  */
3048   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3049     return -1;
3050
3051   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3052     return 1;
3053
3054   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3055     return -1;
3056
3057   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3058     return 1;
3059
3060   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3061     return -1;
3062
3063   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3064     return 1;
3065
3066   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3067     return -1;
3068
3069   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3070     return 1;
3071
3072   return 0;
3073 }
3074
3075 /* Search SYMS for a symbol of the given VALUE.  */
3076
3077 static asymbol *
3078 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3079 {
3080   long mid;
3081
3082   if (id == -1)
3083     {
3084       while (lo < hi)
3085         {
3086           mid = (lo + hi) >> 1;
3087           if (syms[mid]->value + syms[mid]->section->vma < value)
3088             lo = mid + 1;
3089           else if (syms[mid]->value + syms[mid]->section->vma > value)
3090             hi = mid;
3091           else
3092             return syms[mid];
3093         }
3094     }
3095   else
3096     {
3097       while (lo < hi)
3098         {
3099           mid = (lo + hi) >> 1;
3100           if (syms[mid]->section->id < id)
3101             lo = mid + 1;
3102           else if (syms[mid]->section->id > id)
3103             hi = mid;
3104           else if (syms[mid]->value < value)
3105             lo = mid + 1;
3106           else if (syms[mid]->value > value)
3107             hi = mid;
3108           else
3109             return syms[mid];
3110         }
3111     }
3112   return NULL;
3113 }
3114
3115 static bfd_boolean
3116 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3117 {
3118   bfd_vma vma = *(bfd_vma *) ptr;
3119   return ((section->flags & SEC_ALLOC) != 0
3120           && section->vma <= vma
3121           && vma < section->vma + section->size);
3122 }
3123
3124 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3125    entry syms.  Also generate @plt symbols for the glink branch table.  */
3126
3127 static long
3128 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3129                                 long static_count, asymbol **static_syms,
3130                                 long dyn_count, asymbol **dyn_syms,
3131                                 asymbol **ret)
3132 {
3133   asymbol *s;
3134   long i;
3135   long count;
3136   char *names;
3137   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3138   asection *opd = NULL;
3139   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3140   asymbol **syms;
3141   int abi = abiversion (abfd);
3142
3143   *ret = NULL;
3144
3145   if (abi < 2)
3146     {
3147       opd = bfd_get_section_by_name (abfd, ".opd");
3148       if (opd == NULL && abi == 1)
3149         return 0;
3150     }
3151
3152   symcount = static_count;
3153   if (!relocatable)
3154     symcount += dyn_count;
3155   if (symcount == 0)
3156     return 0;
3157
3158   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3159   if (syms == NULL)
3160     return -1;
3161
3162   if (!relocatable && static_count != 0 && dyn_count != 0)
3163     {
3164       /* Use both symbol tables.  */
3165       memcpy (syms, static_syms, static_count * sizeof (*syms));
3166       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3167     }
3168   else if (!relocatable && static_count == 0)
3169     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3170   else
3171     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3172
3173   synthetic_relocatable = relocatable;
3174   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3175
3176   if (!relocatable && symcount > 1)
3177     {
3178       long j;
3179       /* Trim duplicate syms, since we may have merged the normal and
3180          dynamic symbols.  Actually, we only care about syms that have
3181          different values, so trim any with the same value.  */
3182       for (i = 1, j = 1; i < symcount; ++i)
3183         if (syms[i - 1]->value + syms[i - 1]->section->vma
3184             != syms[i]->value + syms[i]->section->vma)
3185           syms[j++] = syms[i];
3186       symcount = j;
3187     }
3188
3189   i = 0;
3190   if (strcmp (syms[i]->section->name, ".opd") == 0)
3191     ++i;
3192   codesecsym = i;
3193
3194   for (; i < symcount; ++i)
3195     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3196          != (SEC_CODE | SEC_ALLOC))
3197         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3198       break;
3199   codesecsymend = i;
3200
3201   for (; i < symcount; ++i)
3202     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3203       break;
3204   secsymend = i;
3205
3206   for (; i < symcount; ++i)
3207     if (strcmp (syms[i]->section->name, ".opd") != 0)
3208       break;
3209   opdsymend = i;
3210
3211   for (; i < symcount; ++i)
3212     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3213         != (SEC_CODE | SEC_ALLOC))
3214       break;
3215   symcount = i;
3216
3217   count = 0;
3218
3219   if (relocatable)
3220     {
3221       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3222       arelent *r;
3223       size_t size;
3224       long relcount;
3225
3226       if (opdsymend == secsymend)
3227         goto done;
3228
3229       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3230       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3231       if (relcount == 0)
3232         goto done;
3233
3234       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3235         {
3236           count = -1;
3237           goto done;
3238         }
3239
3240       size = 0;
3241       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3242         {
3243           asymbol *sym;
3244
3245           while (r < opd->relocation + relcount
3246                  && r->address < syms[i]->value + opd->vma)
3247             ++r;
3248
3249           if (r == opd->relocation + relcount)
3250             break;
3251
3252           if (r->address != syms[i]->value + opd->vma)
3253             continue;
3254
3255           if (r->howto->type != R_PPC64_ADDR64)
3256             continue;
3257
3258           sym = *r->sym_ptr_ptr;
3259           if (!sym_exists_at (syms, opdsymend, symcount,
3260                               sym->section->id, sym->value + r->addend))
3261             {
3262               ++count;
3263               size += sizeof (asymbol);
3264               size += strlen (syms[i]->name) + 2;
3265             }
3266         }
3267
3268       s = *ret = bfd_malloc (size);
3269       if (s == NULL)
3270         {
3271           count = -1;
3272           goto done;
3273         }
3274
3275       names = (char *) (s + count);
3276
3277       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3278         {
3279           asymbol *sym;
3280
3281           while (r < opd->relocation + relcount
3282                  && r->address < syms[i]->value + opd->vma)
3283             ++r;
3284
3285           if (r == opd->relocation + relcount)
3286             break;
3287
3288           if (r->address != syms[i]->value + opd->vma)
3289             continue;
3290
3291           if (r->howto->type != R_PPC64_ADDR64)
3292             continue;
3293
3294           sym = *r->sym_ptr_ptr;
3295           if (!sym_exists_at (syms, opdsymend, symcount,
3296                               sym->section->id, sym->value + r->addend))
3297             {
3298               size_t len;
3299
3300               *s = *syms[i];
3301               s->flags |= BSF_SYNTHETIC;
3302               s->section = sym->section;
3303               s->value = sym->value + r->addend;
3304               s->name = names;
3305               *names++ = '.';
3306               len = strlen (syms[i]->name);
3307               memcpy (names, syms[i]->name, len + 1);
3308               names += len + 1;
3309               /* Have udata.p point back to the original symbol this
3310                  synthetic symbol was derived from.  */
3311               s->udata.p = syms[i];
3312               s++;
3313             }
3314         }
3315     }
3316   else
3317     {
3318       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3319       bfd_byte *contents = NULL;
3320       size_t size;
3321       long plt_count = 0;
3322       bfd_vma glink_vma = 0, resolv_vma = 0;
3323       asection *dynamic, *glink = NULL, *relplt = NULL;
3324       arelent *p;
3325
3326       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3327         {
3328         free_contents_and_exit:
3329           if (contents)
3330             free (contents);
3331           count = -1;
3332           goto done;
3333         }
3334
3335       size = 0;
3336       for (i = secsymend; i < opdsymend; ++i)
3337         {
3338           bfd_vma ent;
3339
3340           /* Ignore bogus symbols.  */
3341           if (syms[i]->value > opd->size - 8)
3342             continue;
3343
3344           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3345           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3346             {
3347               ++count;
3348               size += sizeof (asymbol);
3349               size += strlen (syms[i]->name) + 2;
3350             }
3351         }
3352
3353       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3354       if (dyn_count != 0
3355           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3356         {
3357           bfd_byte *dynbuf, *extdyn, *extdynend;
3358           size_t extdynsize;
3359           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3360
3361           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3362             goto free_contents_and_exit;
3363
3364           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3365           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3366
3367           extdyn = dynbuf;
3368           extdynend = extdyn + dynamic->size;
3369           for (; extdyn < extdynend; extdyn += extdynsize)
3370             {
3371               Elf_Internal_Dyn dyn;
3372               (*swap_dyn_in) (abfd, extdyn, &dyn);
3373
3374               if (dyn.d_tag == DT_NULL)
3375                 break;
3376
3377               if (dyn.d_tag == DT_PPC64_GLINK)
3378                 {
3379                   /* The first glink stub starts at offset 32; see
3380                      comment in ppc64_elf_finish_dynamic_sections. */
3381                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3382                   /* The .glink section usually does not survive the final
3383                      link; search for the section (usually .text) where the
3384                      glink stubs now reside.  */
3385                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3386                                                 &glink_vma);
3387                   break;
3388                 }
3389             }
3390
3391           free (dynbuf);
3392         }
3393
3394       if (glink != NULL)
3395         {
3396           /* Determine __glink trampoline by reading the relative branch
3397              from the first glink stub.  */
3398           bfd_byte buf[4];
3399           unsigned int off = 0;
3400
3401           while (bfd_get_section_contents (abfd, glink, buf,
3402                                            glink_vma + off - glink->vma, 4))
3403             {
3404               unsigned int insn = bfd_get_32 (abfd, buf);
3405               insn ^= B_DOT;
3406               if ((insn & ~0x3fffffc) == 0)
3407                 {
3408                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3409                   break;
3410                 }
3411               off += 4;
3412               if (off > 4)
3413                 break;
3414             }
3415
3416           if (resolv_vma)
3417             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3418
3419           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3420           if (relplt != NULL)
3421             {
3422               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3423               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3424                 goto free_contents_and_exit;
3425
3426               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3427               size += plt_count * sizeof (asymbol);
3428
3429               p = relplt->relocation;
3430               for (i = 0; i < plt_count; i++, p++)
3431                 {
3432                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3433                   if (p->addend != 0)
3434                     size += sizeof ("+0x") - 1 + 16;
3435                 }
3436             }
3437         }
3438
3439       s = *ret = bfd_malloc (size);
3440       if (s == NULL)
3441         goto free_contents_and_exit;
3442
3443       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3444
3445       for (i = secsymend; i < opdsymend; ++i)
3446         {
3447           bfd_vma ent;
3448
3449           if (syms[i]->value > opd->size - 8)
3450             continue;
3451
3452           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3453           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3454             {
3455               long lo, hi;
3456               size_t len;
3457               asection *sec = abfd->sections;
3458
3459               *s = *syms[i];
3460               lo = codesecsym;
3461               hi = codesecsymend;
3462               while (lo < hi)
3463                 {
3464                   long mid = (lo + hi) >> 1;
3465                   if (syms[mid]->section->vma < ent)
3466                     lo = mid + 1;
3467                   else if (syms[mid]->section->vma > ent)
3468                     hi = mid;
3469                   else
3470                     {
3471                       sec = syms[mid]->section;
3472                       break;
3473                     }
3474                 }
3475
3476               if (lo >= hi && lo > codesecsym)
3477                 sec = syms[lo - 1]->section;
3478
3479               for (; sec != NULL; sec = sec->next)
3480                 {
3481                   if (sec->vma > ent)
3482                     break;
3483                   /* SEC_LOAD may not be set if SEC is from a separate debug
3484                      info file.  */
3485                   if ((sec->flags & SEC_ALLOC) == 0)
3486                     break;
3487                   if ((sec->flags & SEC_CODE) != 0)
3488                     s->section = sec;
3489                 }
3490               s->flags |= BSF_SYNTHETIC;
3491               s->value = ent - s->section->vma;
3492               s->name = names;
3493               *names++ = '.';
3494               len = strlen (syms[i]->name);
3495               memcpy (names, syms[i]->name, len + 1);
3496               names += len + 1;
3497               /* Have udata.p point back to the original symbol this
3498                  synthetic symbol was derived from.  */
3499               s->udata.p = syms[i];
3500               s++;
3501             }
3502         }
3503       free (contents);
3504
3505       if (glink != NULL && relplt != NULL)
3506         {
3507           if (resolv_vma)
3508             {
3509               /* Add a symbol for the main glink trampoline.  */
3510               memset (s, 0, sizeof *s);
3511               s->the_bfd = abfd;
3512               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3513               s->section = glink;
3514               s->value = resolv_vma - glink->vma;
3515               s->name = names;
3516               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3517               names += sizeof ("__glink_PLTresolve");
3518               s++;
3519               count++;
3520             }
3521
3522           /* FIXME: It would be very much nicer to put sym@plt on the
3523              stub rather than on the glink branch table entry.  The
3524              objdump disassembler would then use a sensible symbol
3525              name on plt calls.  The difficulty in doing so is
3526              a) finding the stubs, and,
3527              b) matching stubs against plt entries, and,
3528              c) there can be multiple stubs for a given plt entry.
3529
3530              Solving (a) could be done by code scanning, but older
3531              ppc64 binaries used different stubs to current code.
3532              (b) is the tricky one since you need to known the toc
3533              pointer for at least one function that uses a pic stub to
3534              be able to calculate the plt address referenced.
3535              (c) means gdb would need to set multiple breakpoints (or
3536              find the glink branch itself) when setting breakpoints
3537              for pending shared library loads.  */
3538           p = relplt->relocation;
3539           for (i = 0; i < plt_count; i++, p++)
3540             {
3541               size_t len;
3542
3543               *s = **p->sym_ptr_ptr;
3544               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3545                  we are defining a symbol, ensure one of them is set.  */
3546               if ((s->flags & BSF_LOCAL) == 0)
3547                 s->flags |= BSF_GLOBAL;
3548               s->flags |= BSF_SYNTHETIC;
3549               s->section = glink;
3550               s->value = glink_vma - glink->vma;
3551               s->name = names;
3552               s->udata.p = NULL;
3553               len = strlen ((*p->sym_ptr_ptr)->name);
3554               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3555               names += len;
3556               if (p->addend != 0)
3557                 {
3558                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3559                   names += sizeof ("+0x") - 1;
3560                   bfd_sprintf_vma (abfd, names, p->addend);
3561                   names += strlen (names);
3562                 }
3563               memcpy (names, "@plt", sizeof ("@plt"));
3564               names += sizeof ("@plt");
3565               s++;
3566               if (abi < 2)
3567                 {
3568                   glink_vma += 8;
3569                   if (i >= 0x8000)
3570                     glink_vma += 4;
3571                 }
3572               else
3573                 glink_vma += 4;
3574             }
3575           count += plt_count;
3576         }
3577     }
3578
3579  done:
3580   free (syms);
3581   return count;
3582 }
3583 \f
3584 /* The following functions are specific to the ELF linker, while
3585    functions above are used generally.  Those named ppc64_elf_* are
3586    called by the main ELF linker code.  They appear in this file more
3587    or less in the order in which they are called.  eg.
3588    ppc64_elf_check_relocs is called early in the link process,
3589    ppc64_elf_finish_dynamic_sections is one of the last functions
3590    called.
3591
3592    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3593    functions have both a function code symbol and a function descriptor
3594    symbol.  A call to foo in a relocatable object file looks like:
3595
3596    .            .text
3597    .    x:
3598    .            bl      .foo
3599    .            nop
3600
3601    The function definition in another object file might be:
3602
3603    .            .section .opd
3604    .    foo:    .quad   .foo
3605    .            .quad   .TOC.@tocbase
3606    .            .quad   0
3607    .
3608    .            .text
3609    .    .foo:   blr
3610
3611    When the linker resolves the call during a static link, the branch
3612    unsurprisingly just goes to .foo and the .opd information is unused.
3613    If the function definition is in a shared library, things are a little
3614    different:  The call goes via a plt call stub, the opd information gets
3615    copied to the plt, and the linker patches the nop.
3616
3617    .    x:
3618    .            bl      .foo_stub
3619    .            ld      2,40(1)
3620    .
3621    .
3622    .    .foo_stub:
3623    .            std     2,40(1)                 # in practice, the call stub
3624    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3625    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3626    .            ld      12,0(11)
3627    .            ld      2,8(11)
3628    .            mtctr   12
3629    .            ld      11,16(11)
3630    .            bctr
3631    .
3632    .            .section .plt
3633    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3634
3635    The "reloc ()" notation is supposed to indicate that the linker emits
3636    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3637    copying.
3638
3639    What are the difficulties here?  Well, firstly, the relocations
3640    examined by the linker in check_relocs are against the function code
3641    sym .foo, while the dynamic relocation in the plt is emitted against
3642    the function descriptor symbol, foo.  Somewhere along the line, we need
3643    to carefully copy dynamic link information from one symbol to the other.
3644    Secondly, the generic part of the elf linker will make .foo a dynamic
3645    symbol as is normal for most other backends.  We need foo dynamic
3646    instead, at least for an application final link.  However, when
3647    creating a shared library containing foo, we need to have both symbols
3648    dynamic so that references to .foo are satisfied during the early
3649    stages of linking.  Otherwise the linker might decide to pull in a
3650    definition from some other object, eg. a static library.
3651
3652    Update: As of August 2004, we support a new convention.  Function
3653    calls may use the function descriptor symbol, ie. "bl foo".  This
3654    behaves exactly as "bl .foo".  */
3655
3656 /* Of those relocs that might be copied as dynamic relocs, this function
3657    selects those that must be copied when linking a shared library,
3658    even when the symbol is local.  */
3659
3660 static int
3661 must_be_dyn_reloc (struct bfd_link_info *info,
3662                    enum elf_ppc64_reloc_type r_type)
3663 {
3664   switch (r_type)
3665     {
3666     default:
3667       return 1;
3668
3669     case R_PPC64_REL32:
3670     case R_PPC64_REL64:
3671     case R_PPC64_REL30:
3672       return 0;
3673
3674     case R_PPC64_TPREL16:
3675     case R_PPC64_TPREL16_LO:
3676     case R_PPC64_TPREL16_HI:
3677     case R_PPC64_TPREL16_HA:
3678     case R_PPC64_TPREL16_DS:
3679     case R_PPC64_TPREL16_LO_DS:
3680     case R_PPC64_TPREL16_HIGH:
3681     case R_PPC64_TPREL16_HIGHA:
3682     case R_PPC64_TPREL16_HIGHER:
3683     case R_PPC64_TPREL16_HIGHERA:
3684     case R_PPC64_TPREL16_HIGHEST:
3685     case R_PPC64_TPREL16_HIGHESTA:
3686     case R_PPC64_TPREL64:
3687       return !info->executable;
3688     }
3689 }
3690
3691 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3692    copying dynamic variables from a shared lib into an app's dynbss
3693    section, and instead use a dynamic relocation to point into the
3694    shared lib.  With code that gcc generates, it's vital that this be
3695    enabled;  In the PowerPC64 ABI, the address of a function is actually
3696    the address of a function descriptor, which resides in the .opd
3697    section.  gcc uses the descriptor directly rather than going via the
3698    GOT as some other ABI's do, which means that initialized function
3699    pointers must reference the descriptor.  Thus, a function pointer
3700    initialized to the address of a function in a shared library will
3701    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3702    redefines the function descriptor symbol to point to the copy.  This
3703    presents a problem as a plt entry for that function is also
3704    initialized from the function descriptor symbol and the copy reloc
3705    may not be initialized first.  */
3706 #define ELIMINATE_COPY_RELOCS 1
3707
3708 /* Section name for stubs is the associated section name plus this
3709    string.  */
3710 #define STUB_SUFFIX ".stub"
3711
3712 /* Linker stubs.
3713    ppc_stub_long_branch:
3714    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3715    destination, but a 24 bit branch in a stub section will reach.
3716    .    b       dest
3717
3718    ppc_stub_plt_branch:
3719    Similar to the above, but a 24 bit branch in the stub section won't
3720    reach its destination.
3721    .    addis   %r11,%r2,xxx@toc@ha
3722    .    ld      %r12,xxx@toc@l(%r11)
3723    .    mtctr   %r12
3724    .    bctr
3725
3726    ppc_stub_plt_call:
3727    Used to call a function in a shared library.  If it so happens that
3728    the plt entry referenced crosses a 64k boundary, then an extra
3729    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3730    .    std     %r2,40(%r1)
3731    .    addis   %r11,%r2,xxx@toc@ha
3732    .    ld      %r12,xxx+0@toc@l(%r11)
3733    .    mtctr   %r12
3734    .    ld      %r2,xxx+8@toc@l(%r11)
3735    .    ld      %r11,xxx+16@toc@l(%r11)
3736    .    bctr
3737
3738    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3739    code to adjust the value and save r2 to support multiple toc sections.
3740    A ppc_stub_long_branch with an r2 offset looks like:
3741    .    std     %r2,40(%r1)
3742    .    addis   %r2,%r2,off@ha
3743    .    addi    %r2,%r2,off@l
3744    .    b       dest
3745
3746    A ppc_stub_plt_branch with an r2 offset looks like:
3747    .    std     %r2,40(%r1)
3748    .    addis   %r11,%r2,xxx@toc@ha
3749    .    ld      %r12,xxx@toc@l(%r11)
3750    .    addis   %r2,%r2,off@ha
3751    .    addi    %r2,%r2,off@l
3752    .    mtctr   %r12
3753    .    bctr
3754
3755    In cases where the "addis" instruction would add zero, the "addis" is
3756    omitted and following instructions modified slightly in some cases.
3757 */
3758
3759 enum ppc_stub_type {
3760   ppc_stub_none,
3761   ppc_stub_long_branch,
3762   ppc_stub_long_branch_r2off,
3763   ppc_stub_plt_branch,
3764   ppc_stub_plt_branch_r2off,
3765   ppc_stub_plt_call,
3766   ppc_stub_plt_call_r2save
3767 };
3768
3769 struct ppc_stub_hash_entry {
3770
3771   /* Base hash table entry structure.  */
3772   struct bfd_hash_entry root;
3773
3774   enum ppc_stub_type stub_type;
3775
3776   /* The stub section.  */
3777   asection *stub_sec;
3778
3779   /* Offset within stub_sec of the beginning of this stub.  */
3780   bfd_vma stub_offset;
3781
3782   /* Given the symbol's value and its section we can determine its final
3783      value when building the stubs (so the stub knows where to jump.  */
3784   bfd_vma target_value;
3785   asection *target_section;
3786
3787   /* The symbol table entry, if any, that this was derived from.  */
3788   struct ppc_link_hash_entry *h;
3789   struct plt_entry *plt_ent;
3790
3791   /* Where this stub is being called from, or, in the case of combined
3792      stub sections, the first input section in the group.  */
3793   asection *id_sec;
3794
3795   /* Symbol st_other.  */
3796   unsigned char other;
3797 };
3798
3799 struct ppc_branch_hash_entry {
3800
3801   /* Base hash table entry structure.  */
3802   struct bfd_hash_entry root;
3803
3804   /* Offset within branch lookup table.  */
3805   unsigned int offset;
3806
3807   /* Generation marker.  */
3808   unsigned int iter;
3809 };
3810
3811 /* Used to track dynamic relocations for local symbols.  */
3812 struct ppc_dyn_relocs
3813 {
3814   struct ppc_dyn_relocs *next;
3815
3816   /* The input section of the reloc.  */
3817   asection *sec;
3818
3819   /* Total number of relocs copied for the input section.  */
3820   unsigned int count : 31;
3821
3822   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3823   unsigned int ifunc : 1;
3824 };
3825
3826 struct ppc_link_hash_entry
3827 {
3828   struct elf_link_hash_entry elf;
3829
3830   union {
3831     /* A pointer to the most recently used stub hash entry against this
3832        symbol.  */
3833     struct ppc_stub_hash_entry *stub_cache;
3834
3835     /* A pointer to the next symbol starting with a '.'  */
3836     struct ppc_link_hash_entry *next_dot_sym;
3837   } u;
3838
3839   /* Track dynamic relocs copied for this symbol.  */
3840   struct elf_dyn_relocs *dyn_relocs;
3841
3842   /* Link between function code and descriptor symbols.  */
3843   struct ppc_link_hash_entry *oh;
3844
3845   /* Flag function code and descriptor symbols.  */
3846   unsigned int is_func:1;
3847   unsigned int is_func_descriptor:1;
3848   unsigned int fake:1;
3849
3850   /* Whether global opd/toc sym has been adjusted or not.
3851      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3852      should be set for all globals defined in any opd/toc section.  */
3853   unsigned int adjust_done:1;
3854
3855   /* Set if we twiddled this symbol to weak at some stage.  */
3856   unsigned int was_undefined:1;
3857
3858   /* Contexts in which symbol is used in the GOT (or TOC).
3859      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3860      corresponding relocs are encountered during check_relocs.
3861      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3862      indicate the corresponding GOT entry type is not needed.
3863      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3864      a TPREL one.  We use a separate flag rather than setting TPREL
3865      just for convenience in distinguishing the two cases.  */
3866 #define TLS_GD           1      /* GD reloc. */
3867 #define TLS_LD           2      /* LD reloc. */
3868 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3869 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3870 #define TLS_TLS         16      /* Any TLS reloc.  */
3871 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3872 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3873 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3874   unsigned char tls_mask;
3875 };
3876
3877 /* ppc64 ELF linker hash table.  */
3878
3879 struct ppc_link_hash_table
3880 {
3881   struct elf_link_hash_table elf;
3882
3883   /* The stub hash table.  */
3884   struct bfd_hash_table stub_hash_table;
3885
3886   /* Another hash table for plt_branch stubs.  */
3887   struct bfd_hash_table branch_hash_table;
3888
3889   /* Hash table for function prologue tocsave.  */
3890   htab_t tocsave_htab;
3891
3892   /* Various options and other info passed from the linker.  */
3893   struct ppc64_elf_params *params;
3894
3895   /* Array to keep track of which stub sections have been created, and
3896      information on stub grouping.  */
3897   struct map_stub {
3898     /* This is the section to which stubs in the group will be attached.  */
3899     asection *link_sec;
3900     /* The stub section.  */
3901     asection *stub_sec;
3902     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3903     bfd_vma toc_off;
3904   } *stub_group;
3905
3906   /* Temp used when calculating TOC pointers.  */
3907   bfd_vma toc_curr;
3908   bfd *toc_bfd;
3909   asection *toc_first_sec;
3910
3911   /* Highest input section id.  */
3912   int top_id;
3913
3914   /* Highest output section index.  */
3915   int top_index;
3916
3917   /* Used when adding symbols.  */
3918   struct ppc_link_hash_entry *dot_syms;
3919
3920   /* List of input sections for each output section.  */
3921   asection **input_list;
3922
3923   /* Shortcuts to get to dynamic linker sections.  */
3924   asection *dynbss;
3925   asection *relbss;
3926   asection *glink;
3927   asection *sfpr;
3928   asection *brlt;
3929   asection *relbrlt;
3930   asection *glink_eh_frame;
3931
3932   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3933   struct ppc_link_hash_entry *tls_get_addr;
3934   struct ppc_link_hash_entry *tls_get_addr_fd;
3935
3936   /* The size of reliplt used by got entry relocs.  */
3937   bfd_size_type got_reli_size;
3938
3939   /* Statistics.  */
3940   unsigned long stub_count[ppc_stub_plt_call_r2save];
3941
3942   /* Number of stubs against global syms.  */
3943   unsigned long stub_globals;
3944
3945   /* Set if we're linking code with function descriptors.  */
3946   unsigned int opd_abi:1;
3947
3948   /* Support for multiple toc sections.  */
3949   unsigned int do_multi_toc:1;
3950   unsigned int multi_toc_needed:1;
3951   unsigned int second_toc_pass:1;
3952   unsigned int do_toc_opt:1;
3953
3954   /* Set on error.  */
3955   unsigned int stub_error:1;
3956
3957   /* Temp used by ppc64_elf_before_check_relocs.  */
3958   unsigned int twiddled_syms:1;
3959
3960   /* Incremented every time we size stubs.  */
3961   unsigned int stub_iteration;
3962
3963   /* Small local sym cache.  */
3964   struct sym_cache sym_cache;
3965 };
3966
3967 /* Rename some of the generic section flags to better document how they
3968    are used here.  */
3969
3970 /* Nonzero if this section has TLS related relocations.  */
3971 #define has_tls_reloc sec_flg0
3972
3973 /* Nonzero if this section has a call to __tls_get_addr.  */
3974 #define has_tls_get_addr_call sec_flg1
3975
3976 /* Nonzero if this section has any toc or got relocs.  */
3977 #define has_toc_reloc sec_flg2
3978
3979 /* Nonzero if this section has a call to another section that uses
3980    the toc or got.  */
3981 #define makes_toc_func_call sec_flg3
3982
3983 /* Recursion protection when determining above flag.  */
3984 #define call_check_in_progress sec_flg4
3985 #define call_check_done sec_flg5
3986
3987 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3988
3989 #define ppc_hash_table(p) \
3990   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3991   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3992
3993 #define ppc_stub_hash_lookup(table, string, create, copy) \
3994   ((struct ppc_stub_hash_entry *) \
3995    bfd_hash_lookup ((table), (string), (create), (copy)))
3996
3997 #define ppc_branch_hash_lookup(table, string, create, copy) \
3998   ((struct ppc_branch_hash_entry *) \
3999    bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001 /* Create an entry in the stub hash table.  */
4002
4003 static struct bfd_hash_entry *
4004 stub_hash_newfunc (struct bfd_hash_entry *entry,
4005                    struct bfd_hash_table *table,
4006                    const char *string)
4007 {
4008   /* Allocate the structure if it has not already been allocated by a
4009      subclass.  */
4010   if (entry == NULL)
4011     {
4012       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4013       if (entry == NULL)
4014         return entry;
4015     }
4016
4017   /* Call the allocation method of the superclass.  */
4018   entry = bfd_hash_newfunc (entry, table, string);
4019   if (entry != NULL)
4020     {
4021       struct ppc_stub_hash_entry *eh;
4022
4023       /* Initialize the local fields.  */
4024       eh = (struct ppc_stub_hash_entry *) entry;
4025       eh->stub_type = ppc_stub_none;
4026       eh->stub_sec = NULL;
4027       eh->stub_offset = 0;
4028       eh->target_value = 0;
4029       eh->target_section = NULL;
4030       eh->h = NULL;
4031       eh->plt_ent = NULL;
4032       eh->id_sec = NULL;
4033       eh->other = 0;
4034     }
4035
4036   return entry;
4037 }
4038
4039 /* Create an entry in the branch hash table.  */
4040
4041 static struct bfd_hash_entry *
4042 branch_hash_newfunc (struct bfd_hash_entry *entry,
4043                      struct bfd_hash_table *table,
4044                      const char *string)
4045 {
4046   /* Allocate the structure if it has not already been allocated by a
4047      subclass.  */
4048   if (entry == NULL)
4049     {
4050       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4051       if (entry == NULL)
4052         return entry;
4053     }
4054
4055   /* Call the allocation method of the superclass.  */
4056   entry = bfd_hash_newfunc (entry, table, string);
4057   if (entry != NULL)
4058     {
4059       struct ppc_branch_hash_entry *eh;
4060
4061       /* Initialize the local fields.  */
4062       eh = (struct ppc_branch_hash_entry *) entry;
4063       eh->offset = 0;
4064       eh->iter = 0;
4065     }
4066
4067   return entry;
4068 }
4069
4070 /* Create an entry in a ppc64 ELF linker hash table.  */
4071
4072 static struct bfd_hash_entry *
4073 link_hash_newfunc (struct bfd_hash_entry *entry,
4074                    struct bfd_hash_table *table,
4075                    const char *string)
4076 {
4077   /* Allocate the structure if it has not already been allocated by a
4078      subclass.  */
4079   if (entry == NULL)
4080     {
4081       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4082       if (entry == NULL)
4083         return entry;
4084     }
4085
4086   /* Call the allocation method of the superclass.  */
4087   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4088   if (entry != NULL)
4089     {
4090       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4091
4092       memset (&eh->u.stub_cache, 0,
4093               (sizeof (struct ppc_link_hash_entry)
4094                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4095
4096       /* When making function calls, old ABI code references function entry
4097          points (dot symbols), while new ABI code references the function
4098          descriptor symbol.  We need to make any combination of reference and
4099          definition work together, without breaking archive linking.
4100
4101          For a defined function "foo" and an undefined call to "bar":
4102          An old object defines "foo" and ".foo", references ".bar" (possibly
4103          "bar" too).
4104          A new object defines "foo" and references "bar".
4105
4106          A new object thus has no problem with its undefined symbols being
4107          satisfied by definitions in an old object.  On the other hand, the
4108          old object won't have ".bar" satisfied by a new object.
4109
4110          Keep a list of newly added dot-symbols.  */
4111
4112       if (string[0] == '.')
4113         {
4114           struct ppc_link_hash_table *htab;
4115
4116           htab = (struct ppc_link_hash_table *) table;
4117           eh->u.next_dot_sym = htab->dot_syms;
4118           htab->dot_syms = eh;
4119         }
4120     }
4121
4122   return entry;
4123 }
4124
4125 struct tocsave_entry {
4126   asection *sec;
4127   bfd_vma offset;
4128 };
4129
4130 static hashval_t
4131 tocsave_htab_hash (const void *p)
4132 {
4133   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4134   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4135 }
4136
4137 static int
4138 tocsave_htab_eq (const void *p1, const void *p2)
4139 {
4140   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4141   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4142   return e1->sec == e2->sec && e1->offset == e2->offset;
4143 }
4144
4145 /* Create a ppc64 ELF linker hash table.  */
4146
4147 static struct bfd_link_hash_table *
4148 ppc64_elf_link_hash_table_create (bfd *abfd)
4149 {
4150   struct ppc_link_hash_table *htab;
4151   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4152
4153   htab = bfd_zmalloc (amt);
4154   if (htab == NULL)
4155     return NULL;
4156
4157   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4158                                       sizeof (struct ppc_link_hash_entry),
4159                                       PPC64_ELF_DATA))
4160     {
4161       free (htab);
4162       return NULL;
4163     }
4164
4165   /* Init the stub hash table too.  */
4166   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4167                             sizeof (struct ppc_stub_hash_entry)))
4168     {
4169       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4170       return NULL;
4171     }
4172
4173   /* And the branch hash table.  */
4174   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175                             sizeof (struct ppc_branch_hash_entry)))
4176     {
4177       bfd_hash_table_free (&htab->stub_hash_table);
4178       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4179       return NULL;
4180     }
4181
4182   htab->tocsave_htab = htab_try_create (1024,
4183                                         tocsave_htab_hash,
4184                                         tocsave_htab_eq,
4185                                         NULL);
4186   if (htab->tocsave_htab == NULL)
4187     {
4188       bfd_hash_table_free (&htab->branch_hash_table);
4189       bfd_hash_table_free (&htab->stub_hash_table);
4190       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4191       return NULL;
4192     }
4193
4194   /* Initializing two fields of the union is just cosmetic.  We really
4195      only care about glist, but when compiled on a 32-bit host the
4196      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4197      debugger inspection of these fields look nicer.  */
4198   htab->elf.init_got_refcount.refcount = 0;
4199   htab->elf.init_got_refcount.glist = NULL;
4200   htab->elf.init_plt_refcount.refcount = 0;
4201   htab->elf.init_plt_refcount.glist = NULL;
4202   htab->elf.init_got_offset.offset = 0;
4203   htab->elf.init_got_offset.glist = NULL;
4204   htab->elf.init_plt_offset.offset = 0;
4205   htab->elf.init_plt_offset.glist = NULL;
4206
4207   return &htab->elf.root;
4208 }
4209
4210 /* Free the derived linker hash table.  */
4211
4212 static void
4213 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4214 {
4215   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4216
4217   bfd_hash_table_free (&htab->stub_hash_table);
4218   bfd_hash_table_free (&htab->branch_hash_table);
4219   if (htab->tocsave_htab)
4220     htab_delete (htab->tocsave_htab);
4221   _bfd_elf_link_hash_table_free (hash);
4222 }
4223
4224 /* Create sections for linker generated code.  */
4225
4226 static bfd_boolean
4227 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4228 {
4229   struct ppc_link_hash_table *htab;
4230   flagword flags;
4231
4232   htab = ppc_hash_table (info);
4233
4234   /* Create .sfpr for code to save and restore fp regs.  */
4235   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4236            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4237   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4238                                                    flags);
4239   if (htab->sfpr == NULL
4240       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4241     return FALSE;
4242
4243   /* Create .glink for lazy dynamic linking support.  */
4244   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4245                                                     flags);
4246   if (htab->glink == NULL
4247       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4248     return FALSE;
4249
4250   if (!info->no_ld_generated_unwind_info)
4251     {
4252       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4253                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4254       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4255                                                                  ".eh_frame",
4256                                                                  flags);
4257       if (htab->glink_eh_frame == NULL
4258           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4259         return FALSE;
4260     }
4261
4262   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4263   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4264   if (htab->elf.iplt == NULL
4265       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4266     return FALSE;
4267
4268   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4269            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->elf.irelplt
4271     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4272   if (htab->elf.irelplt == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4274     return FALSE;
4275
4276   /* Create branch lookup table for plt_branch stubs.  */
4277   flags = (SEC_ALLOC | SEC_LOAD
4278            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4279   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4280                                                    flags);
4281   if (htab->brlt == NULL
4282       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4283     return FALSE;
4284
4285   if (!info->shared)
4286     return TRUE;
4287
4288   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4289            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4290   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4291                                                       ".rela.branch_lt",
4292                                                       flags);
4293   if (htab->relbrlt == NULL
4294       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4295     return FALSE;
4296
4297   return TRUE;
4298 }
4299
4300 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4301
4302 bfd_boolean
4303 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4304                          struct ppc64_elf_params *params)
4305 {
4306   struct ppc_link_hash_table *htab;
4307
4308   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4309
4310 /* Always hook our dynamic sections into the first bfd, which is the
4311    linker created stub bfd.  This ensures that the GOT header is at
4312    the start of the output TOC section.  */
4313   htab = ppc_hash_table (info);
4314   if (htab == NULL)
4315     return FALSE;
4316   htab->elf.dynobj = params->stub_bfd;
4317   htab->params = params;
4318
4319   if (info->relocatable)
4320     return TRUE;
4321
4322   return create_linkage_sections (htab->elf.dynobj, info);
4323 }
4324
4325 /* Build a name for an entry in the stub hash table.  */
4326
4327 static char *
4328 ppc_stub_name (const asection *input_section,
4329                const asection *sym_sec,
4330                const struct ppc_link_hash_entry *h,
4331                const Elf_Internal_Rela *rel)
4332 {
4333   char *stub_name;
4334   ssize_t len;
4335
4336   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4337      offsets from a sym as a branch target?  In fact, we could
4338      probably assume the addend is always zero.  */
4339   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4340
4341   if (h)
4342     {
4343       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4344       stub_name = bfd_malloc (len);
4345       if (stub_name == NULL)
4346         return stub_name;
4347
4348       len = sprintf (stub_name, "%08x.%s+%x",
4349                      input_section->id & 0xffffffff,
4350                      h->elf.root.root.string,
4351                      (int) rel->r_addend & 0xffffffff);
4352     }
4353   else
4354     {
4355       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4356       stub_name = bfd_malloc (len);
4357       if (stub_name == NULL)
4358         return stub_name;
4359
4360       len = sprintf (stub_name, "%08x.%x:%x+%x",
4361                      input_section->id & 0xffffffff,
4362                      sym_sec->id & 0xffffffff,
4363                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4364                      (int) rel->r_addend & 0xffffffff);
4365     }
4366   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4367     stub_name[len - 2] = 0;
4368   return stub_name;
4369 }
4370
4371 /* Look up an entry in the stub hash.  Stub entries are cached because
4372    creating the stub name takes a bit of time.  */
4373
4374 static struct ppc_stub_hash_entry *
4375 ppc_get_stub_entry (const asection *input_section,
4376                     const asection *sym_sec,
4377                     struct ppc_link_hash_entry *h,
4378                     const Elf_Internal_Rela *rel,
4379                     struct ppc_link_hash_table *htab)
4380 {
4381   struct ppc_stub_hash_entry *stub_entry;
4382   const asection *id_sec;
4383
4384   /* If this input section is part of a group of sections sharing one
4385      stub section, then use the id of the first section in the group.
4386      Stub names need to include a section id, as there may well be
4387      more than one stub used to reach say, printf, and we need to
4388      distinguish between them.  */
4389   id_sec = htab->stub_group[input_section->id].link_sec;
4390
4391   if (h != NULL && h->u.stub_cache != NULL
4392       && h->u.stub_cache->h == h
4393       && h->u.stub_cache->id_sec == id_sec)
4394     {
4395       stub_entry = h->u.stub_cache;
4396     }
4397   else
4398     {
4399       char *stub_name;
4400
4401       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4402       if (stub_name == NULL)
4403         return NULL;
4404
4405       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4406                                          stub_name, FALSE, FALSE);
4407       if (h != NULL)
4408         h->u.stub_cache = stub_entry;
4409
4410       free (stub_name);
4411     }
4412
4413   return stub_entry;
4414 }
4415
4416 /* Add a new stub entry to the stub hash.  Not all fields of the new
4417    stub entry are initialised.  */
4418
4419 static struct ppc_stub_hash_entry *
4420 ppc_add_stub (const char *stub_name,
4421               asection *section,
4422               struct bfd_link_info *info)
4423 {
4424   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4425   asection *link_sec;
4426   asection *stub_sec;
4427   struct ppc_stub_hash_entry *stub_entry;
4428
4429   link_sec = htab->stub_group[section->id].link_sec;
4430   stub_sec = htab->stub_group[section->id].stub_sec;
4431   if (stub_sec == NULL)
4432     {
4433       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4434       if (stub_sec == NULL)
4435         {
4436           size_t namelen;
4437           bfd_size_type len;
4438           char *s_name;
4439
4440           namelen = strlen (link_sec->name);
4441           len = namelen + sizeof (STUB_SUFFIX);
4442           s_name = bfd_alloc (htab->params->stub_bfd, len);
4443           if (s_name == NULL)
4444             return NULL;
4445
4446           memcpy (s_name, link_sec->name, namelen);
4447           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4448           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4449           if (stub_sec == NULL)
4450             return NULL;
4451           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4452         }
4453       htab->stub_group[section->id].stub_sec = stub_sec;
4454     }
4455
4456   /* Enter this entry into the linker stub hash table.  */
4457   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4458                                      TRUE, FALSE);
4459   if (stub_entry == NULL)
4460     {
4461       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4462                               section->owner, stub_name);
4463       return NULL;
4464     }
4465
4466   stub_entry->stub_sec = stub_sec;
4467   stub_entry->stub_offset = 0;
4468   stub_entry->id_sec = link_sec;
4469   return stub_entry;
4470 }
4471
4472 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4473    not already done.  */
4474
4475 static bfd_boolean
4476 create_got_section (bfd *abfd, struct bfd_link_info *info)
4477 {
4478   asection *got, *relgot;
4479   flagword flags;
4480   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4481
4482   if (!is_ppc64_elf (abfd))
4483     return FALSE;
4484   if (htab == NULL)
4485     return FALSE;
4486
4487   if (!htab->elf.sgot
4488       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4489     return FALSE;
4490
4491   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4492            | SEC_LINKER_CREATED);
4493
4494   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4495   if (!got
4496       || !bfd_set_section_alignment (abfd, got, 3))
4497     return FALSE;
4498
4499   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4500                                                flags | SEC_READONLY);
4501   if (!relgot
4502       || ! bfd_set_section_alignment (abfd, relgot, 3))
4503     return FALSE;
4504
4505   ppc64_elf_tdata (abfd)->got = got;
4506   ppc64_elf_tdata (abfd)->relgot = relgot;
4507   return TRUE;
4508 }
4509
4510 /* Create the dynamic sections, and set up shortcuts.  */
4511
4512 static bfd_boolean
4513 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4514 {
4515   struct ppc_link_hash_table *htab;
4516
4517   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4518     return FALSE;
4519
4520   htab = ppc_hash_table (info);
4521   if (htab == NULL)
4522     return FALSE;
4523
4524   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4525   if (!info->shared)
4526     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4527
4528   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4529       || (!info->shared && !htab->relbss))
4530     abort ();
4531
4532   return TRUE;
4533 }
4534
4535 /* Follow indirect and warning symbol links.  */
4536
4537 static inline struct bfd_link_hash_entry *
4538 follow_link (struct bfd_link_hash_entry *h)
4539 {
4540   while (h->type == bfd_link_hash_indirect
4541          || h->type == bfd_link_hash_warning)
4542     h = h->u.i.link;
4543   return h;
4544 }
4545
4546 static inline struct elf_link_hash_entry *
4547 elf_follow_link (struct elf_link_hash_entry *h)
4548 {
4549   return (struct elf_link_hash_entry *) follow_link (&h->root);
4550 }
4551
4552 static inline struct ppc_link_hash_entry *
4553 ppc_follow_link (struct ppc_link_hash_entry *h)
4554 {
4555   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4556 }
4557
4558 /* Merge PLT info on FROM with that on TO.  */
4559
4560 static void
4561 move_plt_plist (struct ppc_link_hash_entry *from,
4562                 struct ppc_link_hash_entry *to)
4563 {
4564   if (from->elf.plt.plist != NULL)
4565     {
4566       if (to->elf.plt.plist != NULL)
4567         {
4568           struct plt_entry **entp;
4569           struct plt_entry *ent;
4570
4571           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4572             {
4573               struct plt_entry *dent;
4574
4575               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4576                 if (dent->addend == ent->addend)
4577                   {
4578                     dent->plt.refcount += ent->plt.refcount;
4579                     *entp = ent->next;
4580                     break;
4581                   }
4582               if (dent == NULL)
4583                 entp = &ent->next;
4584             }
4585           *entp = to->elf.plt.plist;
4586         }
4587
4588       to->elf.plt.plist = from->elf.plt.plist;
4589       from->elf.plt.plist = NULL;
4590     }
4591 }
4592
4593 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4594
4595 static void
4596 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4597                                 struct elf_link_hash_entry *dir,
4598                                 struct elf_link_hash_entry *ind)
4599 {
4600   struct ppc_link_hash_entry *edir, *eind;
4601
4602   edir = (struct ppc_link_hash_entry *) dir;
4603   eind = (struct ppc_link_hash_entry *) ind;
4604
4605   edir->is_func |= eind->is_func;
4606   edir->is_func_descriptor |= eind->is_func_descriptor;
4607   edir->tls_mask |= eind->tls_mask;
4608   if (eind->oh != NULL)
4609     edir->oh = ppc_follow_link (eind->oh);
4610
4611   /* If called to transfer flags for a weakdef during processing
4612      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4613      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4614   if (!(ELIMINATE_COPY_RELOCS
4615         && eind->elf.root.type != bfd_link_hash_indirect
4616         && edir->elf.dynamic_adjusted))
4617     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4618
4619   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4620   edir->elf.ref_regular |= eind->elf.ref_regular;
4621   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4622   edir->elf.needs_plt |= eind->elf.needs_plt;
4623   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4624
4625   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4626   if (eind->dyn_relocs != NULL)
4627     {
4628       if (edir->dyn_relocs != NULL)
4629         {
4630           struct elf_dyn_relocs **pp;
4631           struct elf_dyn_relocs *p;
4632
4633           /* Add reloc counts against the indirect sym to the direct sym
4634              list.  Merge any entries against the same section.  */
4635           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4636             {
4637               struct elf_dyn_relocs *q;
4638
4639               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4640                 if (q->sec == p->sec)
4641                   {
4642                     q->pc_count += p->pc_count;
4643                     q->count += p->count;
4644                     *pp = p->next;
4645                     break;
4646                   }
4647               if (q == NULL)
4648                 pp = &p->next;
4649             }
4650           *pp = edir->dyn_relocs;
4651         }
4652
4653       edir->dyn_relocs = eind->dyn_relocs;
4654       eind->dyn_relocs = NULL;
4655     }
4656
4657   /* If we were called to copy over info for a weak sym, that's all.
4658      You might think dyn_relocs need not be copied over;  After all,
4659      both syms will be dynamic or both non-dynamic so we're just
4660      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4661      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4662      dyn_relocs in read-only sections, and it does so on what is the
4663      DIR sym here.  */
4664   if (eind->elf.root.type != bfd_link_hash_indirect)
4665     return;
4666
4667   /* Copy over got entries that we may have already seen to the
4668      symbol which just became indirect.  */
4669   if (eind->elf.got.glist != NULL)
4670     {
4671       if (edir->elf.got.glist != NULL)
4672         {
4673           struct got_entry **entp;
4674           struct got_entry *ent;
4675
4676           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4677             {
4678               struct got_entry *dent;
4679
4680               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4681                 if (dent->addend == ent->addend
4682                     && dent->owner == ent->owner
4683                     && dent->tls_type == ent->tls_type)
4684                   {
4685                     dent->got.refcount += ent->got.refcount;
4686                     *entp = ent->next;
4687                     break;
4688                   }
4689               if (dent == NULL)
4690                 entp = &ent->next;
4691             }
4692           *entp = edir->elf.got.glist;
4693         }
4694
4695       edir->elf.got.glist = eind->elf.got.glist;
4696       eind->elf.got.glist = NULL;
4697     }
4698
4699   /* And plt entries.  */
4700   move_plt_plist (eind, edir);
4701
4702   if (eind->elf.dynindx != -1)
4703     {
4704       if (edir->elf.dynindx != -1)
4705         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4706                                 edir->elf.dynstr_index);
4707       edir->elf.dynindx = eind->elf.dynindx;
4708       edir->elf.dynstr_index = eind->elf.dynstr_index;
4709       eind->elf.dynindx = -1;
4710       eind->elf.dynstr_index = 0;
4711     }
4712 }
4713
4714 /* Find the function descriptor hash entry from the given function code
4715    hash entry FH.  Link the entries via their OH fields.  */
4716
4717 static struct ppc_link_hash_entry *
4718 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4719 {
4720   struct ppc_link_hash_entry *fdh = fh->oh;
4721
4722   if (fdh == NULL)
4723     {
4724       const char *fd_name = fh->elf.root.root.string + 1;
4725
4726       fdh = (struct ppc_link_hash_entry *)
4727         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4728       if (fdh == NULL)
4729         return fdh;
4730
4731       fdh->is_func_descriptor = 1;
4732       fdh->oh = fh;
4733       fh->is_func = 1;
4734       fh->oh = fdh;
4735     }
4736
4737   return ppc_follow_link (fdh);
4738 }
4739
4740 /* Make a fake function descriptor sym for the code sym FH.  */
4741
4742 static struct ppc_link_hash_entry *
4743 make_fdh (struct bfd_link_info *info,
4744           struct ppc_link_hash_entry *fh)
4745 {
4746   bfd *abfd;
4747   asymbol *newsym;
4748   struct bfd_link_hash_entry *bh;
4749   struct ppc_link_hash_entry *fdh;
4750
4751   abfd = fh->elf.root.u.undef.abfd;
4752   newsym = bfd_make_empty_symbol (abfd);
4753   newsym->name = fh->elf.root.root.string + 1;
4754   newsym->section = bfd_und_section_ptr;
4755   newsym->value = 0;
4756   newsym->flags = BSF_WEAK;
4757
4758   bh = NULL;
4759   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4760                                          newsym->flags, newsym->section,
4761                                          newsym->value, NULL, FALSE, FALSE,
4762                                          &bh))
4763     return NULL;
4764
4765   fdh = (struct ppc_link_hash_entry *) bh;
4766   fdh->elf.non_elf = 0;
4767   fdh->fake = 1;
4768   fdh->is_func_descriptor = 1;
4769   fdh->oh = fh;
4770   fh->is_func = 1;
4771   fh->oh = fdh;
4772   return fdh;
4773 }
4774
4775 /* Fix function descriptor symbols defined in .opd sections to be
4776    function type.  */
4777
4778 static bfd_boolean
4779 ppc64_elf_add_symbol_hook (bfd *ibfd,
4780                            struct bfd_link_info *info,
4781                            Elf_Internal_Sym *isym,
4782                            const char **name,
4783                            flagword *flags ATTRIBUTE_UNUSED,
4784                            asection **sec,
4785                            bfd_vma *value ATTRIBUTE_UNUSED)
4786 {
4787   if ((ibfd->flags & DYNAMIC) == 0
4788       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4789     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4790
4791   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4792     {
4793       if ((ibfd->flags & DYNAMIC) == 0)
4794         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4795     }
4796   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4797     ;
4798   else if (*sec != NULL
4799            && strcmp ((*sec)->name, ".opd") == 0)
4800     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4801
4802   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4803     {
4804       if (abiversion (ibfd) == 0)
4805         set_abiversion (ibfd, 2);
4806       else if (abiversion (ibfd) == 1)
4807         {
4808           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4809                                     " for ABI version 1\n"), name);
4810           bfd_set_error (bfd_error_bad_value);
4811           return FALSE;
4812         }
4813     }
4814
4815   return TRUE;
4816 }
4817
4818 /* Merge non-visibility st_other attributes: local entry point.  */
4819
4820 static void
4821 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4822                                   const Elf_Internal_Sym *isym,
4823                                   bfd_boolean definition,
4824                                   bfd_boolean dynamic)
4825 {
4826   if (definition && !dynamic)
4827     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4828                 | ELF_ST_VISIBILITY (h->other));
4829 }
4830
4831 /* This function makes an old ABI object reference to ".bar" cause the
4832    inclusion of a new ABI object archive that defines "bar".
4833    NAME is a symbol defined in an archive.  Return a symbol in the hash
4834    table that might be satisfied by the archive symbols.  */
4835
4836 static struct elf_link_hash_entry *
4837 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4838                                  struct bfd_link_info *info,
4839                                  const char *name)
4840 {
4841   struct elf_link_hash_entry *h;
4842   char *dot_name;
4843   size_t len;
4844
4845   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4846   if (h != NULL
4847       /* Don't return this sym if it is a fake function descriptor
4848          created by add_symbol_adjust.  */
4849       && !(h->root.type == bfd_link_hash_undefweak
4850            && ((struct ppc_link_hash_entry *) h)->fake))
4851     return h;
4852
4853   if (name[0] == '.')
4854     return h;
4855
4856   len = strlen (name);
4857   dot_name = bfd_alloc (abfd, len + 2);
4858   if (dot_name == NULL)
4859     return (struct elf_link_hash_entry *) 0 - 1;
4860   dot_name[0] = '.';
4861   memcpy (dot_name + 1, name, len + 1);
4862   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4863   bfd_release (abfd, dot_name);
4864   return h;
4865 }
4866
4867 /* This function satisfies all old ABI object references to ".bar" if a
4868    new ABI object defines "bar".  Well, at least, undefined dot symbols
4869    are made weak.  This stops later archive searches from including an
4870    object if we already have a function descriptor definition.  It also
4871    prevents the linker complaining about undefined symbols.
4872    We also check and correct mismatched symbol visibility here.  The
4873    most restrictive visibility of the function descriptor and the
4874    function entry symbol is used.  */
4875
4876 static bfd_boolean
4877 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4878 {
4879   struct ppc_link_hash_table *htab;
4880   struct ppc_link_hash_entry *fdh;
4881
4882   if (eh->elf.root.type == bfd_link_hash_indirect)
4883     return TRUE;
4884
4885   if (eh->elf.root.type == bfd_link_hash_warning)
4886     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4887
4888   if (eh->elf.root.root.string[0] != '.')
4889     abort ();
4890
4891   htab = ppc_hash_table (info);
4892   if (htab == NULL)
4893     return FALSE;
4894
4895   fdh = lookup_fdh (eh, htab);
4896   if (fdh == NULL)
4897     {
4898       if (!info->relocatable
4899           && (eh->elf.root.type == bfd_link_hash_undefined
4900               || eh->elf.root.type == bfd_link_hash_undefweak)
4901           && eh->elf.ref_regular)
4902         {
4903           /* Make an undefweak function descriptor sym, which is enough to
4904              pull in an --as-needed shared lib, but won't cause link
4905              errors.  Archives are handled elsewhere.  */
4906           fdh = make_fdh (info, eh);
4907           if (fdh == NULL)
4908             return FALSE;
4909           fdh->elf.ref_regular = 1;
4910         }
4911     }
4912   else
4913     {
4914       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4915       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4916       if (entry_vis < descr_vis)
4917         fdh->elf.other += entry_vis - descr_vis;
4918       else if (entry_vis > descr_vis)
4919         eh->elf.other += descr_vis - entry_vis;
4920
4921       if ((fdh->elf.root.type == bfd_link_hash_defined
4922            || fdh->elf.root.type == bfd_link_hash_defweak)
4923           && eh->elf.root.type == bfd_link_hash_undefined)
4924         {
4925           eh->elf.root.type = bfd_link_hash_undefweak;
4926           eh->was_undefined = 1;
4927           htab->twiddled_syms = 1;
4928         }
4929     }
4930
4931   return TRUE;
4932 }
4933
4934 /* Set up opd section info and abiversion for IBFD, and process list
4935    of dot-symbols we made in link_hash_newfunc.  */
4936
4937 static bfd_boolean
4938 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4939 {
4940   struct ppc_link_hash_table *htab;
4941   struct ppc_link_hash_entry **p, *eh;
4942
4943   if (!is_ppc64_elf (info->output_bfd))
4944     return TRUE;
4945   htab = ppc_hash_table (info);
4946   if (htab == NULL)
4947     return FALSE;
4948
4949   if (is_ppc64_elf (ibfd))
4950     {
4951       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4952
4953       if (opd != NULL && opd->size != 0)
4954         {
4955           if (abiversion (ibfd) == 0)
4956             set_abiversion (ibfd, 1);
4957           else if (abiversion (ibfd) == 2)
4958             {
4959               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4960                                         " version %d\n"),
4961                                       ibfd, abiversion (ibfd));
4962               bfd_set_error (bfd_error_bad_value);
4963               return FALSE;
4964             }
4965
4966           if ((ibfd->flags & DYNAMIC) == 0
4967               && (opd->flags & SEC_RELOC) != 0
4968               && opd->reloc_count != 0
4969               && !bfd_is_abs_section (opd->output_section))
4970             {
4971               /* Garbage collection needs some extra help with .opd sections.
4972                  We don't want to necessarily keep everything referenced by
4973                  relocs in .opd, as that would keep all functions.  Instead,
4974                  if we reference an .opd symbol (a function descriptor), we
4975                  want to keep the function code symbol's section.  This is
4976                  easy for global symbols, but for local syms we need to keep
4977                  information about the associated function section.  */
4978               bfd_size_type amt;
4979               asection **opd_sym_map;
4980
4981               amt = opd->size * sizeof (*opd_sym_map) / 8;
4982               opd_sym_map = bfd_zalloc (ibfd, amt);
4983               if (opd_sym_map == NULL)
4984                 return FALSE;
4985               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4986               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4987               ppc64_elf_section_data (opd)->sec_type = sec_opd;
4988             }
4989         }
4990
4991       /* For input files without an explicit abiversion in e_flags
4992          we should have flagged any with symbol st_other bits set
4993          as ELFv1 and above flagged those with .opd as ELFv2.
4994          Set the output abiversion if not yet set, and for any input
4995          still ambiguous, take its abiversion from the output.
4996          Differences in ABI are reported later.  */
4997       if (abiversion (info->output_bfd) == 0)
4998         set_abiversion (info->output_bfd, abiversion (ibfd));
4999       else if (abiversion (ibfd) == 0)
5000         set_abiversion (ibfd, abiversion (info->output_bfd));
5001
5002       p = &htab->dot_syms;
5003       while ((eh = *p) != NULL)
5004         {
5005           *p = NULL;
5006           if (&eh->elf == htab->elf.hgot)
5007             ;
5008           else if (htab->elf.hgot == NULL
5009                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5010             htab->elf.hgot = &eh->elf;
5011           else if (!add_symbol_adjust (eh, info))
5012             return FALSE;
5013           p = &eh->u.next_dot_sym;
5014         }
5015     }
5016
5017   /* Clear the list for non-ppc64 input files.  */
5018   p = &htab->dot_syms;
5019   while ((eh = *p) != NULL)
5020     {
5021       *p = NULL;
5022       p = &eh->u.next_dot_sym;
5023     }
5024
5025   /* We need to fix the undefs list for any syms we have twiddled to
5026      undef_weak.  */
5027   if (htab->twiddled_syms)
5028     {
5029       bfd_link_repair_undef_list (&htab->elf.root);
5030       htab->twiddled_syms = 0;
5031     }
5032   return TRUE;
5033 }
5034
5035 /* Undo hash table changes when an --as-needed input file is determined
5036    not to be needed.  */
5037
5038 static bfd_boolean
5039 ppc64_elf_notice_as_needed (bfd *ibfd,
5040                             struct bfd_link_info *info,
5041                             enum notice_asneeded_action act)
5042 {
5043   if (act == notice_not_needed)
5044     {
5045       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5046
5047       if (htab == NULL)
5048         return FALSE;
5049
5050       htab->dot_syms = NULL;
5051     }
5052   return _bfd_elf_notice_as_needed (ibfd, info, act);
5053 }
5054
5055 /* If --just-symbols against a final linked binary, then assume we need
5056    toc adjusting stubs when calling functions defined there.  */
5057
5058 static void
5059 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5060 {
5061   if ((sec->flags & SEC_CODE) != 0
5062       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5063       && is_ppc64_elf (sec->owner))
5064     {
5065       if (abiversion (sec->owner) >= 2
5066           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5067         sec->has_toc_reloc = 1;
5068     }
5069   _bfd_elf_link_just_syms (sec, info);
5070 }
5071
5072 static struct plt_entry **
5073 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5074                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5075 {
5076   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5077   struct plt_entry **local_plt;
5078   unsigned char *local_got_tls_masks;
5079
5080   if (local_got_ents == NULL)
5081     {
5082       bfd_size_type size = symtab_hdr->sh_info;
5083
5084       size *= (sizeof (*local_got_ents)
5085                + sizeof (*local_plt)
5086                + sizeof (*local_got_tls_masks));
5087       local_got_ents = bfd_zalloc (abfd, size);
5088       if (local_got_ents == NULL)
5089         return NULL;
5090       elf_local_got_ents (abfd) = local_got_ents;
5091     }
5092
5093   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5094     {
5095       struct got_entry *ent;
5096
5097       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5098         if (ent->addend == r_addend
5099             && ent->owner == abfd
5100             && ent->tls_type == tls_type)
5101           break;
5102       if (ent == NULL)
5103         {
5104           bfd_size_type amt = sizeof (*ent);
5105           ent = bfd_alloc (abfd, amt);
5106           if (ent == NULL)
5107             return FALSE;
5108           ent->next = local_got_ents[r_symndx];
5109           ent->addend = r_addend;
5110           ent->owner = abfd;
5111           ent->tls_type = tls_type;
5112           ent->is_indirect = FALSE;
5113           ent->got.refcount = 0;
5114           local_got_ents[r_symndx] = ent;
5115         }
5116       ent->got.refcount += 1;
5117     }
5118
5119   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5120   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5121   local_got_tls_masks[r_symndx] |= tls_type;
5122
5123   return local_plt + r_symndx;
5124 }
5125
5126 static bfd_boolean
5127 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5128 {
5129   struct plt_entry *ent;
5130
5131   for (ent = *plist; ent != NULL; ent = ent->next)
5132     if (ent->addend == addend)
5133       break;
5134   if (ent == NULL)
5135     {
5136       bfd_size_type amt = sizeof (*ent);
5137       ent = bfd_alloc (abfd, amt);
5138       if (ent == NULL)
5139         return FALSE;
5140       ent->next = *plist;
5141       ent->addend = addend;
5142       ent->plt.refcount = 0;
5143       *plist = ent;
5144     }
5145   ent->plt.refcount += 1;
5146   return TRUE;
5147 }
5148
5149 static bfd_boolean
5150 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5151 {
5152   return (r_type == R_PPC64_REL24
5153           || r_type == R_PPC64_REL14
5154           || r_type == R_PPC64_REL14_BRTAKEN
5155           || r_type == R_PPC64_REL14_BRNTAKEN
5156           || r_type == R_PPC64_ADDR24
5157           || r_type == R_PPC64_ADDR14
5158           || r_type == R_PPC64_ADDR14_BRTAKEN
5159           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5160 }
5161
5162 /* Look through the relocs for a section during the first phase, and
5163    calculate needed space in the global offset table, procedure
5164    linkage table, and dynamic reloc sections.  */
5165
5166 static bfd_boolean
5167 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5168                         asection *sec, const Elf_Internal_Rela *relocs)
5169 {
5170   struct ppc_link_hash_table *htab;
5171   Elf_Internal_Shdr *symtab_hdr;
5172   struct elf_link_hash_entry **sym_hashes;
5173   const Elf_Internal_Rela *rel;
5174   const Elf_Internal_Rela *rel_end;
5175   asection *sreloc;
5176   asection **opd_sym_map;
5177   struct elf_link_hash_entry *tga, *dottga;
5178
5179   if (info->relocatable)
5180     return TRUE;
5181
5182   /* Don't do anything special with non-loaded, non-alloced sections.
5183      In particular, any relocs in such sections should not affect GOT
5184      and PLT reference counting (ie. we don't allow them to create GOT
5185      or PLT entries), there's no possibility or desire to optimize TLS
5186      relocs, and there's not much point in propagating relocs to shared
5187      libs that the dynamic linker won't relocate.  */
5188   if ((sec->flags & SEC_ALLOC) == 0)
5189     return TRUE;
5190
5191   BFD_ASSERT (is_ppc64_elf (abfd));
5192
5193   htab = ppc_hash_table (info);
5194   if (htab == NULL)
5195     return FALSE;
5196
5197   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5198                               FALSE, FALSE, TRUE);
5199   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5200                                  FALSE, FALSE, TRUE);
5201   symtab_hdr = &elf_symtab_hdr (abfd);
5202   sym_hashes = elf_sym_hashes (abfd);
5203   sreloc = NULL;
5204   opd_sym_map = NULL;
5205   if (ppc64_elf_section_data (sec) != NULL
5206       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5207     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5208
5209   rel_end = relocs + sec->reloc_count;
5210   for (rel = relocs; rel < rel_end; rel++)
5211     {
5212       unsigned long r_symndx;
5213       struct elf_link_hash_entry *h;
5214       enum elf_ppc64_reloc_type r_type;
5215       int tls_type;
5216       struct _ppc64_elf_section_data *ppc64_sec;
5217       struct plt_entry **ifunc;
5218
5219       r_symndx = ELF64_R_SYM (rel->r_info);
5220       if (r_symndx < symtab_hdr->sh_info)
5221         h = NULL;
5222       else
5223         {
5224           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5225           h = elf_follow_link (h);
5226
5227           /* PR15323, ref flags aren't set for references in the same
5228              object.  */
5229           h->root.non_ir_ref = 1;
5230
5231           if (h == htab->elf.hgot)
5232             sec->has_toc_reloc = 1;
5233         }
5234
5235       tls_type = 0;
5236       ifunc = NULL;
5237       if (h != NULL)
5238         {
5239           if (h->type == STT_GNU_IFUNC)
5240             {
5241               h->needs_plt = 1;
5242               ifunc = &h->plt.plist;
5243             }
5244         }
5245       else
5246         {
5247           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5248                                                           abfd, r_symndx);
5249           if (isym == NULL)
5250             return FALSE;
5251
5252           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5253             {
5254               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5255                                              rel->r_addend, PLT_IFUNC);
5256               if (ifunc == NULL)
5257                 return FALSE;
5258             }
5259         }
5260       r_type = ELF64_R_TYPE (rel->r_info);
5261       if (is_branch_reloc (r_type))
5262         {
5263           if (h != NULL && (h == tga || h == dottga))
5264             {
5265               if (rel != relocs
5266                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5267                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5268                 /* We have a new-style __tls_get_addr call with a marker
5269                    reloc.  */
5270                 ;
5271               else
5272                 /* Mark this section as having an old-style call.  */
5273                 sec->has_tls_get_addr_call = 1;
5274             }
5275
5276           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5277           if (ifunc != NULL
5278               && !update_plt_info (abfd, ifunc, rel->r_addend))
5279             return FALSE;
5280         }
5281
5282       switch (r_type)
5283         {
5284         case R_PPC64_TLSGD:
5285         case R_PPC64_TLSLD:
5286           /* These special tls relocs tie a call to __tls_get_addr with
5287              its parameter symbol.  */
5288           break;
5289
5290         case R_PPC64_GOT_TLSLD16:
5291         case R_PPC64_GOT_TLSLD16_LO:
5292         case R_PPC64_GOT_TLSLD16_HI:
5293         case R_PPC64_GOT_TLSLD16_HA:
5294           tls_type = TLS_TLS | TLS_LD;
5295           goto dogottls;
5296
5297         case R_PPC64_GOT_TLSGD16:
5298         case R_PPC64_GOT_TLSGD16_LO:
5299         case R_PPC64_GOT_TLSGD16_HI:
5300         case R_PPC64_GOT_TLSGD16_HA:
5301           tls_type = TLS_TLS | TLS_GD;
5302           goto dogottls;
5303
5304         case R_PPC64_GOT_TPREL16_DS:
5305         case R_PPC64_GOT_TPREL16_LO_DS:
5306         case R_PPC64_GOT_TPREL16_HI:
5307         case R_PPC64_GOT_TPREL16_HA:
5308           if (!info->executable)
5309             info->flags |= DF_STATIC_TLS;
5310           tls_type = TLS_TLS | TLS_TPREL;
5311           goto dogottls;
5312
5313         case R_PPC64_GOT_DTPREL16_DS:
5314         case R_PPC64_GOT_DTPREL16_LO_DS:
5315         case R_PPC64_GOT_DTPREL16_HI:
5316         case R_PPC64_GOT_DTPREL16_HA:
5317           tls_type = TLS_TLS | TLS_DTPREL;
5318         dogottls:
5319           sec->has_tls_reloc = 1;
5320           /* Fall thru */
5321
5322         case R_PPC64_GOT16:
5323         case R_PPC64_GOT16_DS:
5324         case R_PPC64_GOT16_HA:
5325         case R_PPC64_GOT16_HI:
5326         case R_PPC64_GOT16_LO:
5327         case R_PPC64_GOT16_LO_DS:
5328           /* This symbol requires a global offset table entry.  */
5329           sec->has_toc_reloc = 1;
5330           if (r_type == R_PPC64_GOT_TLSLD16
5331               || r_type == R_PPC64_GOT_TLSGD16
5332               || r_type == R_PPC64_GOT_TPREL16_DS
5333               || r_type == R_PPC64_GOT_DTPREL16_DS
5334               || r_type == R_PPC64_GOT16
5335               || r_type == R_PPC64_GOT16_DS)
5336             {
5337               htab->do_multi_toc = 1;
5338               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5339             }
5340
5341           if (ppc64_elf_tdata (abfd)->got == NULL
5342               && !create_got_section (abfd, info))
5343             return FALSE;
5344
5345           if (h != NULL)
5346             {
5347               struct ppc_link_hash_entry *eh;
5348               struct got_entry *ent;
5349
5350               eh = (struct ppc_link_hash_entry *) h;
5351               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5352                 if (ent->addend == rel->r_addend
5353                     && ent->owner == abfd
5354                     && ent->tls_type == tls_type)
5355                   break;
5356               if (ent == NULL)
5357                 {
5358                   bfd_size_type amt = sizeof (*ent);
5359                   ent = bfd_alloc (abfd, amt);
5360                   if (ent == NULL)
5361                     return FALSE;
5362                   ent->next = eh->elf.got.glist;
5363                   ent->addend = rel->r_addend;
5364                   ent->owner = abfd;
5365                   ent->tls_type = tls_type;
5366                   ent->is_indirect = FALSE;
5367                   ent->got.refcount = 0;
5368                   eh->elf.got.glist = ent;
5369                 }
5370               ent->got.refcount += 1;
5371               eh->tls_mask |= tls_type;
5372             }
5373           else
5374             /* This is a global offset table entry for a local symbol.  */
5375             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5376                                         rel->r_addend, tls_type))
5377               return FALSE;
5378
5379           /* We may also need a plt entry if the symbol turns out to be
5380              an ifunc.  */
5381           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5382             {
5383               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5384                 return FALSE;
5385             }
5386           break;
5387
5388         case R_PPC64_PLT16_HA:
5389         case R_PPC64_PLT16_HI:
5390         case R_PPC64_PLT16_LO:
5391         case R_PPC64_PLT32:
5392         case R_PPC64_PLT64:
5393           /* This symbol requires a procedure linkage table entry.  We
5394              actually build the entry in adjust_dynamic_symbol,
5395              because this might be a case of linking PIC code without
5396              linking in any dynamic objects, in which case we don't
5397              need to generate a procedure linkage table after all.  */
5398           if (h == NULL)
5399             {
5400               /* It does not make sense to have a procedure linkage
5401                  table entry for a local symbol.  */
5402               bfd_set_error (bfd_error_bad_value);
5403               return FALSE;
5404             }
5405           else
5406             {
5407               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5408                 return FALSE;
5409               h->needs_plt = 1;
5410               if (h->root.root.string[0] == '.'
5411                   && h->root.root.string[1] != '\0')
5412                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5413             }
5414           break;
5415
5416           /* The following relocations don't need to propagate the
5417              relocation if linking a shared object since they are
5418              section relative.  */
5419         case R_PPC64_SECTOFF:
5420         case R_PPC64_SECTOFF_LO:
5421         case R_PPC64_SECTOFF_HI:
5422         case R_PPC64_SECTOFF_HA:
5423         case R_PPC64_SECTOFF_DS:
5424         case R_PPC64_SECTOFF_LO_DS:
5425         case R_PPC64_DTPREL16:
5426         case R_PPC64_DTPREL16_LO:
5427         case R_PPC64_DTPREL16_HI:
5428         case R_PPC64_DTPREL16_HA:
5429         case R_PPC64_DTPREL16_DS:
5430         case R_PPC64_DTPREL16_LO_DS:
5431         case R_PPC64_DTPREL16_HIGH:
5432         case R_PPC64_DTPREL16_HIGHA:
5433         case R_PPC64_DTPREL16_HIGHER:
5434         case R_PPC64_DTPREL16_HIGHERA:
5435         case R_PPC64_DTPREL16_HIGHEST:
5436         case R_PPC64_DTPREL16_HIGHESTA:
5437           break;
5438
5439           /* Nor do these.  */
5440         case R_PPC64_REL16:
5441         case R_PPC64_REL16_LO:
5442         case R_PPC64_REL16_HI:
5443         case R_PPC64_REL16_HA:
5444           break;
5445
5446           /* Not supported as a dynamic relocation.  */
5447         case R_PPC64_ADDR64_LOCAL:
5448           if (info->shared)
5449             {
5450               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5451                 ppc_howto_init ();
5452               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5453                                         "in shared libraries and PIEs.\n"),
5454                                       abfd, sec, rel->r_offset,
5455                                       ppc64_elf_howto_table[r_type]->name);
5456               bfd_set_error (bfd_error_bad_value);
5457               return FALSE;
5458             }
5459           break;
5460
5461         case R_PPC64_TOC16:
5462         case R_PPC64_TOC16_DS:
5463           htab->do_multi_toc = 1;
5464           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5465         case R_PPC64_TOC16_LO:
5466         case R_PPC64_TOC16_HI:
5467         case R_PPC64_TOC16_HA:
5468         case R_PPC64_TOC16_LO_DS:
5469           sec->has_toc_reloc = 1;
5470           break;
5471
5472           /* This relocation describes the C++ object vtable hierarchy.
5473              Reconstruct it for later use during GC.  */
5474         case R_PPC64_GNU_VTINHERIT:
5475           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5476             return FALSE;
5477           break;
5478
5479           /* This relocation describes which C++ vtable entries are actually
5480              used.  Record for later use during GC.  */
5481         case R_PPC64_GNU_VTENTRY:
5482           BFD_ASSERT (h != NULL);
5483           if (h != NULL
5484               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5485             return FALSE;
5486           break;
5487
5488         case R_PPC64_REL14:
5489         case R_PPC64_REL14_BRTAKEN:
5490         case R_PPC64_REL14_BRNTAKEN:
5491           {
5492             asection *dest = NULL;
5493
5494             /* Heuristic: If jumping outside our section, chances are
5495                we are going to need a stub.  */
5496             if (h != NULL)
5497               {
5498                 /* If the sym is weak it may be overridden later, so
5499                    don't assume we know where a weak sym lives.  */
5500                 if (h->root.type == bfd_link_hash_defined)
5501                   dest = h->root.u.def.section;
5502               }
5503             else
5504               {
5505                 Elf_Internal_Sym *isym;
5506
5507                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5508                                               abfd, r_symndx);
5509                 if (isym == NULL)
5510                   return FALSE;
5511
5512                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5513               }
5514
5515             if (dest != sec)
5516               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5517           }
5518           /* Fall through.  */
5519
5520         case R_PPC64_REL24:
5521           if (h != NULL && ifunc == NULL)
5522             {
5523               /* We may need a .plt entry if the function this reloc
5524                  refers to is in a shared lib.  */
5525               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5526                 return FALSE;
5527               h->needs_plt = 1;
5528               if (h->root.root.string[0] == '.'
5529                   && h->root.root.string[1] != '\0')
5530                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5531               if (h == tga || h == dottga)
5532                 sec->has_tls_reloc = 1;
5533             }
5534           break;
5535
5536         case R_PPC64_TPREL64:
5537           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5538           if (!info->executable)
5539             info->flags |= DF_STATIC_TLS;
5540           goto dotlstoc;
5541
5542         case R_PPC64_DTPMOD64:
5543           if (rel + 1 < rel_end
5544               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5545               && rel[1].r_offset == rel->r_offset + 8)
5546             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5547           else
5548             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5549           goto dotlstoc;
5550
5551         case R_PPC64_DTPREL64:
5552           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5553           if (rel != relocs
5554               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5555               && rel[-1].r_offset == rel->r_offset - 8)
5556             /* This is the second reloc of a dtpmod, dtprel pair.
5557                Don't mark with TLS_DTPREL.  */
5558             goto dodyn;
5559
5560         dotlstoc:
5561           sec->has_tls_reloc = 1;
5562           if (h != NULL)
5563             {
5564               struct ppc_link_hash_entry *eh;
5565               eh = (struct ppc_link_hash_entry *) h;
5566               eh->tls_mask |= tls_type;
5567             }
5568           else
5569             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5570                                         rel->r_addend, tls_type))
5571               return FALSE;
5572
5573           ppc64_sec = ppc64_elf_section_data (sec);
5574           if (ppc64_sec->sec_type != sec_toc)
5575             {
5576               bfd_size_type amt;
5577
5578               /* One extra to simplify get_tls_mask.  */
5579               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5580               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5581               if (ppc64_sec->u.toc.symndx == NULL)
5582                 return FALSE;
5583               amt = sec->size * sizeof (bfd_vma) / 8;
5584               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5585               if (ppc64_sec->u.toc.add == NULL)
5586                 return FALSE;
5587               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5588               ppc64_sec->sec_type = sec_toc;
5589             }
5590           BFD_ASSERT (rel->r_offset % 8 == 0);
5591           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5592           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5593
5594           /* Mark the second slot of a GD or LD entry.
5595              -1 to indicate GD and -2 to indicate LD.  */
5596           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5597             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5598           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5599             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5600           goto dodyn;
5601
5602         case R_PPC64_TPREL16:
5603         case R_PPC64_TPREL16_LO:
5604         case R_PPC64_TPREL16_HI:
5605         case R_PPC64_TPREL16_HA:
5606         case R_PPC64_TPREL16_DS:
5607         case R_PPC64_TPREL16_LO_DS:
5608         case R_PPC64_TPREL16_HIGH:
5609         case R_PPC64_TPREL16_HIGHA:
5610         case R_PPC64_TPREL16_HIGHER:
5611         case R_PPC64_TPREL16_HIGHERA:
5612         case R_PPC64_TPREL16_HIGHEST:
5613         case R_PPC64_TPREL16_HIGHESTA:
5614           if (info->shared)
5615             {
5616               if (!info->executable)
5617                 info->flags |= DF_STATIC_TLS;
5618               goto dodyn;
5619             }
5620           break;
5621
5622         case R_PPC64_ADDR64:
5623           if (opd_sym_map != NULL
5624               && rel + 1 < rel_end
5625               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5626             {
5627               if (h != NULL)
5628                 {
5629                   if (h->root.root.string[0] == '.'
5630                       && h->root.root.string[1] != 0
5631                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5632                     ;
5633                   else
5634                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5635                 }
5636               else
5637                 {
5638                   asection *s;
5639                   Elf_Internal_Sym *isym;
5640
5641                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5642                                                 abfd, r_symndx);
5643                   if (isym == NULL)
5644                     return FALSE;
5645
5646                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5647                   if (s != NULL && s != sec)
5648                     opd_sym_map[rel->r_offset / 8] = s;
5649                 }
5650             }
5651           /* Fall through.  */
5652
5653         case R_PPC64_ADDR16:
5654         case R_PPC64_ADDR16_DS:
5655         case R_PPC64_ADDR16_HA:
5656         case R_PPC64_ADDR16_HI:
5657         case R_PPC64_ADDR16_HIGH:
5658         case R_PPC64_ADDR16_HIGHA:
5659         case R_PPC64_ADDR16_HIGHER:
5660         case R_PPC64_ADDR16_HIGHERA:
5661         case R_PPC64_ADDR16_HIGHEST:
5662         case R_PPC64_ADDR16_HIGHESTA:
5663         case R_PPC64_ADDR16_LO:
5664         case R_PPC64_ADDR16_LO_DS:
5665           if (h != NULL && !info->shared && abiversion (abfd) != 1
5666               && rel->r_addend == 0)
5667             {
5668               /* We may need a .plt entry if this reloc refers to a
5669                  function in a shared lib.  */
5670               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5671                 return FALSE;
5672               h->pointer_equality_needed = 1;
5673             }
5674           /* Fall through.  */
5675
5676         case R_PPC64_REL30:
5677         case R_PPC64_REL32:
5678         case R_PPC64_REL64:
5679         case R_PPC64_ADDR14:
5680         case R_PPC64_ADDR14_BRNTAKEN:
5681         case R_PPC64_ADDR14_BRTAKEN:
5682         case R_PPC64_ADDR24:
5683         case R_PPC64_ADDR32:
5684         case R_PPC64_UADDR16:
5685         case R_PPC64_UADDR32:
5686         case R_PPC64_UADDR64:
5687         case R_PPC64_TOC:
5688           if (h != NULL && !info->shared)
5689             /* We may need a copy reloc.  */
5690             h->non_got_ref = 1;
5691
5692           /* Don't propagate .opd relocs.  */
5693           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5694             break;
5695
5696           /* If we are creating a shared library, and this is a reloc
5697              against a global symbol, or a non PC relative reloc
5698              against a local symbol, then we need to copy the reloc
5699              into the shared library.  However, if we are linking with
5700              -Bsymbolic, we do not need to copy a reloc against a
5701              global symbol which is defined in an object we are
5702              including in the link (i.e., DEF_REGULAR is set).  At
5703              this point we have not seen all the input files, so it is
5704              possible that DEF_REGULAR is not set now but will be set
5705              later (it is never cleared).  In case of a weak definition,
5706              DEF_REGULAR may be cleared later by a strong definition in
5707              a shared library.  We account for that possibility below by
5708              storing information in the dyn_relocs field of the hash
5709              table entry.  A similar situation occurs when creating
5710              shared libraries and symbol visibility changes render the
5711              symbol local.
5712
5713              If on the other hand, we are creating an executable, we
5714              may need to keep relocations for symbols satisfied by a
5715              dynamic library if we manage to avoid copy relocs for the
5716              symbol.  */
5717         dodyn:
5718           if ((info->shared
5719                && (must_be_dyn_reloc (info, r_type)
5720                    || (h != NULL
5721                        && (!SYMBOLIC_BIND (info, h)
5722                            || h->root.type == bfd_link_hash_defweak
5723                            || !h->def_regular))))
5724               || (ELIMINATE_COPY_RELOCS
5725                   && !info->shared
5726                   && h != NULL
5727                   && (h->root.type == bfd_link_hash_defweak
5728                       || !h->def_regular))
5729               || (!info->shared
5730                   && ifunc != NULL))
5731             {
5732               /* We must copy these reloc types into the output file.
5733                  Create a reloc section in dynobj and make room for
5734                  this reloc.  */
5735               if (sreloc == NULL)
5736                 {
5737                   sreloc = _bfd_elf_make_dynamic_reloc_section
5738                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5739
5740                   if (sreloc == NULL)
5741                     return FALSE;
5742                 }
5743
5744               /* If this is a global symbol, we count the number of
5745                  relocations we need for this symbol.  */
5746               if (h != NULL)
5747                 {
5748                   struct elf_dyn_relocs *p;
5749                   struct elf_dyn_relocs **head;
5750
5751                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5752                   p = *head;
5753                   if (p == NULL || p->sec != sec)
5754                     {
5755                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5756                       if (p == NULL)
5757                         return FALSE;
5758                       p->next = *head;
5759                       *head = p;
5760                       p->sec = sec;
5761                       p->count = 0;
5762                       p->pc_count = 0;
5763                     }
5764                   p->count += 1;
5765                   if (!must_be_dyn_reloc (info, r_type))
5766                     p->pc_count += 1;
5767                 }
5768               else
5769                 {
5770                   /* Track dynamic relocs needed for local syms too.
5771                      We really need local syms available to do this
5772                      easily.  Oh well.  */
5773                   struct ppc_dyn_relocs *p;
5774                   struct ppc_dyn_relocs **head;
5775                   bfd_boolean is_ifunc;
5776                   asection *s;
5777                   void *vpp;
5778                   Elf_Internal_Sym *isym;
5779
5780                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5781                                                 abfd, r_symndx);
5782                   if (isym == NULL)
5783                     return FALSE;
5784
5785                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5786                   if (s == NULL)
5787                     s = sec;
5788
5789                   vpp = &elf_section_data (s)->local_dynrel;
5790                   head = (struct ppc_dyn_relocs **) vpp;
5791                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5792                   p = *head;
5793                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5794                     p = p->next;
5795                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5796                     {
5797                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5798                       if (p == NULL)
5799                         return FALSE;
5800                       p->next = *head;
5801                       *head = p;
5802                       p->sec = sec;
5803                       p->ifunc = is_ifunc;
5804                       p->count = 0;
5805                     }
5806                   p->count += 1;
5807                 }
5808             }
5809           break;
5810
5811         default:
5812           break;
5813         }
5814     }
5815
5816   return TRUE;
5817 }
5818
5819 /* Merge backend specific data from an object file to the output
5820    object file when linking.  */
5821
5822 static bfd_boolean
5823 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5824 {
5825   unsigned long iflags, oflags;
5826
5827   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5828     return TRUE;
5829
5830   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5831     return TRUE;
5832
5833   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5834     return FALSE;
5835
5836   iflags = elf_elfheader (ibfd)->e_flags;
5837   oflags = elf_elfheader (obfd)->e_flags;
5838
5839   if (iflags & ~EF_PPC64_ABI)
5840     {
5841       (*_bfd_error_handler)
5842         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5843       bfd_set_error (bfd_error_bad_value);
5844       return FALSE;
5845     }
5846   else if (iflags != oflags && iflags != 0)
5847     {
5848       (*_bfd_error_handler)
5849         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5850          ibfd, iflags, oflags);
5851       bfd_set_error (bfd_error_bad_value);
5852       return FALSE;
5853     }
5854
5855   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5856   _bfd_elf_merge_object_attributes (ibfd, obfd);
5857
5858   return TRUE;
5859 }
5860
5861 static bfd_boolean
5862 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5863 {
5864   /* Print normal ELF private data.  */
5865   _bfd_elf_print_private_bfd_data (abfd, ptr);
5866
5867   if (elf_elfheader (abfd)->e_flags != 0)
5868     {
5869       FILE *file = ptr;
5870
5871       /* xgettext:c-format */
5872       fprintf (file, _("private flags = 0x%lx:"),
5873                elf_elfheader (abfd)->e_flags);
5874
5875       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5876         fprintf (file, _(" [abiv%ld]"),
5877                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5878       fputc ('\n', file);
5879     }
5880
5881   return TRUE;
5882 }
5883
5884 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5885    of the code entry point, and its section.  */
5886
5887 static bfd_vma
5888 opd_entry_value (asection *opd_sec,
5889                  bfd_vma offset,
5890                  asection **code_sec,
5891                  bfd_vma *code_off,
5892                  bfd_boolean in_code_sec)
5893 {
5894   bfd *opd_bfd = opd_sec->owner;
5895   Elf_Internal_Rela *relocs;
5896   Elf_Internal_Rela *lo, *hi, *look;
5897   bfd_vma val;
5898
5899   /* No relocs implies we are linking a --just-symbols object, or looking
5900      at a final linked executable with addr2line or somesuch.  */
5901   if (opd_sec->reloc_count == 0)
5902     {
5903       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5904
5905       if (contents == NULL)
5906         {
5907           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5908             return (bfd_vma) -1;
5909           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5910         }
5911
5912       val = bfd_get_64 (opd_bfd, contents + offset);
5913       if (code_sec != NULL)
5914         {
5915           asection *sec, *likely = NULL;
5916
5917           if (in_code_sec)
5918             {
5919               sec = *code_sec;
5920               if (sec->vma <= val
5921                   && val < sec->vma + sec->size)
5922                 likely = sec;
5923               else
5924                 val = -1;
5925             }
5926           else
5927             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5928               if (sec->vma <= val
5929                   && (sec->flags & SEC_LOAD) != 0
5930                   && (sec->flags & SEC_ALLOC) != 0)
5931                 likely = sec;
5932           if (likely != NULL)
5933             {
5934               *code_sec = likely;
5935               if (code_off != NULL)
5936                 *code_off = val - likely->vma;
5937             }
5938         }
5939       return val;
5940     }
5941
5942   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5943
5944   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5945   if (relocs == NULL)
5946     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5947
5948   /* Go find the opd reloc at the sym address.  */
5949   lo = relocs;
5950   BFD_ASSERT (lo != NULL);
5951   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5952   val = (bfd_vma) -1;
5953   while (lo < hi)
5954     {
5955       look = lo + (hi - lo) / 2;
5956       if (look->r_offset < offset)
5957         lo = look + 1;
5958       else if (look->r_offset > offset)
5959         hi = look;
5960       else
5961         {
5962           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5963
5964           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5965               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5966             {
5967               unsigned long symndx = ELF64_R_SYM (look->r_info);
5968               asection *sec;
5969
5970               if (symndx < symtab_hdr->sh_info
5971                   || elf_sym_hashes (opd_bfd) == NULL)
5972                 {
5973                   Elf_Internal_Sym *sym;
5974
5975                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5976                   if (sym == NULL)
5977                     {
5978                       size_t symcnt = symtab_hdr->sh_info;
5979                       if (elf_sym_hashes (opd_bfd) == NULL)
5980                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5981                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5982                                                   0, NULL, NULL, NULL);
5983                       if (sym == NULL)
5984                         break;
5985                       symtab_hdr->contents = (bfd_byte *) sym;
5986                     }
5987
5988                   sym += symndx;
5989                   val = sym->st_value;
5990                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5991                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5992                 }
5993               else
5994                 {
5995                   struct elf_link_hash_entry **sym_hashes;
5996                   struct elf_link_hash_entry *rh;
5997
5998                   sym_hashes = elf_sym_hashes (opd_bfd);
5999                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6000                   if (rh != NULL)
6001                     {
6002                       rh = elf_follow_link (rh);
6003                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6004                                   || rh->root.type == bfd_link_hash_defweak);
6005                       val = rh->root.u.def.value;
6006                       sec = rh->root.u.def.section;
6007                     }
6008                   else
6009                     {
6010                       /* Handle the odd case where we can be called
6011                          during bfd_elf_link_add_symbols before the
6012                          symbol hashes have been fully populated.  */
6013                       Elf_Internal_Sym *sym;
6014
6015                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6016                                                   symndx, NULL, NULL, NULL);
6017                       if (sym == NULL)
6018                         break;
6019
6020                       val = sym->st_value;
6021                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6022                       free (sym);
6023                     }
6024                 }
6025               val += look->r_addend;
6026               if (code_off != NULL)
6027                 *code_off = val;
6028               if (code_sec != NULL)
6029                 {
6030                   if (in_code_sec && *code_sec != sec)
6031                     return -1;
6032                   else
6033                     *code_sec = sec;
6034                 }
6035               if (sec != NULL && sec->output_section != NULL)
6036                 val += sec->output_section->vma + sec->output_offset;
6037             }
6038           break;
6039         }
6040     }
6041
6042   return val;
6043 }
6044
6045 /* If the ELF symbol SYM might be a function in SEC, return the
6046    function size and set *CODE_OFF to the function's entry point,
6047    otherwise return zero.  */
6048
6049 static bfd_size_type
6050 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6051                               bfd_vma *code_off)
6052 {
6053   bfd_size_type size;
6054
6055   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6056                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6057     return 0;
6058
6059   size = 0;
6060   if (!(sym->flags & BSF_SYNTHETIC))
6061     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6062
6063   if (strcmp (sym->section->name, ".opd") == 0)
6064     {
6065       if (opd_entry_value (sym->section, sym->value,
6066                            &sec, code_off, TRUE) == (bfd_vma) -1)
6067         return 0;
6068       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6069          symbol.  This size has nothing to do with the code size of the
6070          function, which is what we're supposed to return, but the
6071          code size isn't available without looking up the dot-sym.
6072          However, doing that would be a waste of time particularly
6073          since elf_find_function will look at the dot-sym anyway.
6074          Now, elf_find_function will keep the largest size of any
6075          function sym found at the code address of interest, so return
6076          1 here to avoid it incorrectly caching a larger function size
6077          for a small function.  This does mean we return the wrong
6078          size for a new-ABI function of size 24, but all that does is
6079          disable caching for such functions.  */
6080       if (size == 24)
6081         size = 1;
6082     }
6083   else
6084     {
6085       if (sym->section != sec)
6086         return 0;
6087       *code_off = sym->value;
6088     }
6089   if (size == 0)
6090     size = 1;
6091   return size;
6092 }
6093
6094 /* Return true if symbol is defined in a regular object file.  */
6095
6096 static bfd_boolean
6097 is_static_defined (struct elf_link_hash_entry *h)
6098 {
6099   return ((h->root.type == bfd_link_hash_defined
6100            || h->root.type == bfd_link_hash_defweak)
6101           && h->root.u.def.section != NULL
6102           && h->root.u.def.section->output_section != NULL);
6103 }
6104
6105 /* If FDH is a function descriptor symbol, return the associated code
6106    entry symbol if it is defined.  Return NULL otherwise.  */
6107
6108 static struct ppc_link_hash_entry *
6109 defined_code_entry (struct ppc_link_hash_entry *fdh)
6110 {
6111   if (fdh->is_func_descriptor)
6112     {
6113       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6114       if (fh->elf.root.type == bfd_link_hash_defined
6115           || fh->elf.root.type == bfd_link_hash_defweak)
6116         return fh;
6117     }
6118   return NULL;
6119 }
6120
6121 /* If FH is a function code entry symbol, return the associated
6122    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6123
6124 static struct ppc_link_hash_entry *
6125 defined_func_desc (struct ppc_link_hash_entry *fh)
6126 {
6127   if (fh->oh != NULL
6128       && fh->oh->is_func_descriptor)
6129     {
6130       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6131       if (fdh->elf.root.type == bfd_link_hash_defined
6132           || fdh->elf.root.type == bfd_link_hash_defweak)
6133         return fdh;
6134     }
6135   return NULL;
6136 }
6137
6138 /* Mark all our entry sym sections, both opd and code section.  */
6139
6140 static void
6141 ppc64_elf_gc_keep (struct bfd_link_info *info)
6142 {
6143   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6144   struct bfd_sym_chain *sym;
6145
6146   if (htab == NULL)
6147     return;
6148
6149   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6150     {
6151       struct ppc_link_hash_entry *eh, *fh;
6152       asection *sec;
6153
6154       eh = (struct ppc_link_hash_entry *)
6155         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6156       if (eh == NULL)
6157         continue;
6158       if (eh->elf.root.type != bfd_link_hash_defined
6159           && eh->elf.root.type != bfd_link_hash_defweak)
6160         continue;
6161
6162       fh = defined_code_entry (eh);
6163       if (fh != NULL)
6164         {
6165           sec = fh->elf.root.u.def.section;
6166           sec->flags |= SEC_KEEP;
6167         }
6168       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6169                && opd_entry_value (eh->elf.root.u.def.section,
6170                                    eh->elf.root.u.def.value,
6171                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6172         sec->flags |= SEC_KEEP;
6173
6174       sec = eh->elf.root.u.def.section;
6175       sec->flags |= SEC_KEEP;
6176     }
6177 }
6178
6179 /* Mark sections containing dynamically referenced symbols.  When
6180    building shared libraries, we must assume that any visible symbol is
6181    referenced.  */
6182
6183 static bfd_boolean
6184 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6185 {
6186   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6187   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6188   struct ppc_link_hash_entry *fdh;
6189   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6190
6191   /* Dynamic linking info is on the func descriptor sym.  */
6192   fdh = defined_func_desc (eh);
6193   if (fdh != NULL)
6194     eh = fdh;
6195
6196   if ((eh->elf.root.type == bfd_link_hash_defined
6197        || eh->elf.root.type == bfd_link_hash_defweak)
6198       && (eh->elf.ref_dynamic
6199           || (eh->elf.def_regular
6200               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6201               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6202               && (!info->executable
6203                   || info->export_dynamic
6204                   || (eh->elf.dynamic
6205                       && d != NULL
6206                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6207               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6208                   || !bfd_hide_sym_by_version (info->version_info,
6209                                                eh->elf.root.root.string)))))
6210     {
6211       asection *code_sec;
6212       struct ppc_link_hash_entry *fh;
6213
6214       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6215
6216       /* Function descriptor syms cause the associated
6217          function code sym section to be marked.  */
6218       fh = defined_code_entry (eh);
6219       if (fh != NULL)
6220         {
6221           code_sec = fh->elf.root.u.def.section;
6222           code_sec->flags |= SEC_KEEP;
6223         }
6224       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6225                && opd_entry_value (eh->elf.root.u.def.section,
6226                                    eh->elf.root.u.def.value,
6227                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6228         code_sec->flags |= SEC_KEEP;
6229     }
6230
6231   return TRUE;
6232 }
6233
6234 /* Return the section that should be marked against GC for a given
6235    relocation.  */
6236
6237 static asection *
6238 ppc64_elf_gc_mark_hook (asection *sec,
6239                         struct bfd_link_info *info,
6240                         Elf_Internal_Rela *rel,
6241                         struct elf_link_hash_entry *h,
6242                         Elf_Internal_Sym *sym)
6243 {
6244   asection *rsec;
6245
6246   /* Syms return NULL if we're marking .opd, so we avoid marking all
6247      function sections, as all functions are referenced in .opd.  */
6248   rsec = NULL;
6249   if (get_opd_info (sec) != NULL)
6250     return rsec;
6251
6252   if (h != NULL)
6253     {
6254       enum elf_ppc64_reloc_type r_type;
6255       struct ppc_link_hash_entry *eh, *fh, *fdh;
6256
6257       r_type = ELF64_R_TYPE (rel->r_info);
6258       switch (r_type)
6259         {
6260         case R_PPC64_GNU_VTINHERIT:
6261         case R_PPC64_GNU_VTENTRY:
6262           break;
6263
6264         default:
6265           switch (h->root.type)
6266             {
6267             case bfd_link_hash_defined:
6268             case bfd_link_hash_defweak:
6269               eh = (struct ppc_link_hash_entry *) h;
6270               fdh = defined_func_desc (eh);
6271               if (fdh != NULL)
6272                 eh = fdh;
6273
6274               /* Function descriptor syms cause the associated
6275                  function code sym section to be marked.  */
6276               fh = defined_code_entry (eh);
6277               if (fh != NULL)
6278                 {
6279                   /* They also mark their opd section.  */
6280                   eh->elf.root.u.def.section->gc_mark = 1;
6281
6282                   rsec = fh->elf.root.u.def.section;
6283                 }
6284               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6285                        && opd_entry_value (eh->elf.root.u.def.section,
6286                                            eh->elf.root.u.def.value,
6287                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6288                 eh->elf.root.u.def.section->gc_mark = 1;
6289               else
6290                 rsec = h->root.u.def.section;
6291               break;
6292
6293             case bfd_link_hash_common:
6294               rsec = h->root.u.c.p->section;
6295               break;
6296
6297             default:
6298               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6299             }
6300         }
6301     }
6302   else
6303     {
6304       struct _opd_sec_data *opd;
6305
6306       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6307       opd = get_opd_info (rsec);
6308       if (opd != NULL && opd->func_sec != NULL)
6309         {
6310           rsec->gc_mark = 1;
6311
6312           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6313         }
6314     }
6315
6316   return rsec;
6317 }
6318
6319 /* Update the .got, .plt. and dynamic reloc reference counts for the
6320    section being removed.  */
6321
6322 static bfd_boolean
6323 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6324                          asection *sec, const Elf_Internal_Rela *relocs)
6325 {
6326   struct ppc_link_hash_table *htab;
6327   Elf_Internal_Shdr *symtab_hdr;
6328   struct elf_link_hash_entry **sym_hashes;
6329   struct got_entry **local_got_ents;
6330   const Elf_Internal_Rela *rel, *relend;
6331
6332   if (info->relocatable)
6333     return TRUE;
6334
6335   if ((sec->flags & SEC_ALLOC) == 0)
6336     return TRUE;
6337
6338   elf_section_data (sec)->local_dynrel = NULL;
6339
6340   htab = ppc_hash_table (info);
6341   if (htab == NULL)
6342     return FALSE;
6343
6344   symtab_hdr = &elf_symtab_hdr (abfd);
6345   sym_hashes = elf_sym_hashes (abfd);
6346   local_got_ents = elf_local_got_ents (abfd);
6347
6348   relend = relocs + sec->reloc_count;
6349   for (rel = relocs; rel < relend; rel++)
6350     {
6351       unsigned long r_symndx;
6352       enum elf_ppc64_reloc_type r_type;
6353       struct elf_link_hash_entry *h = NULL;
6354       unsigned char tls_type = 0;
6355
6356       r_symndx = ELF64_R_SYM (rel->r_info);
6357       r_type = ELF64_R_TYPE (rel->r_info);
6358       if (r_symndx >= symtab_hdr->sh_info)
6359         {
6360           struct ppc_link_hash_entry *eh;
6361           struct elf_dyn_relocs **pp;
6362           struct elf_dyn_relocs *p;
6363
6364           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6365           h = elf_follow_link (h);
6366           eh = (struct ppc_link_hash_entry *) h;
6367
6368           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6369             if (p->sec == sec)
6370               {
6371                 /* Everything must go for SEC.  */
6372                 *pp = p->next;
6373                 break;
6374               }
6375         }
6376
6377       if (is_branch_reloc (r_type))
6378         {
6379           struct plt_entry **ifunc = NULL;
6380           if (h != NULL)
6381             {
6382               if (h->type == STT_GNU_IFUNC)
6383                 ifunc = &h->plt.plist;
6384             }
6385           else if (local_got_ents != NULL)
6386             {
6387               struct plt_entry **local_plt = (struct plt_entry **)
6388                 (local_got_ents + symtab_hdr->sh_info);
6389               unsigned char *local_got_tls_masks = (unsigned char *)
6390                 (local_plt + symtab_hdr->sh_info);
6391               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6392                 ifunc = local_plt + r_symndx;
6393             }
6394           if (ifunc != NULL)
6395             {
6396               struct plt_entry *ent;
6397
6398               for (ent = *ifunc; ent != NULL; ent = ent->next)
6399                 if (ent->addend == rel->r_addend)
6400                   break;
6401               if (ent == NULL)
6402                 abort ();
6403               if (ent->plt.refcount > 0)
6404                 ent->plt.refcount -= 1;
6405               continue;
6406             }
6407         }
6408
6409       switch (r_type)
6410         {
6411         case R_PPC64_GOT_TLSLD16:
6412         case R_PPC64_GOT_TLSLD16_LO:
6413         case R_PPC64_GOT_TLSLD16_HI:
6414         case R_PPC64_GOT_TLSLD16_HA:
6415           tls_type = TLS_TLS | TLS_LD;
6416           goto dogot;
6417
6418         case R_PPC64_GOT_TLSGD16:
6419         case R_PPC64_GOT_TLSGD16_LO:
6420         case R_PPC64_GOT_TLSGD16_HI:
6421         case R_PPC64_GOT_TLSGD16_HA:
6422           tls_type = TLS_TLS | TLS_GD;
6423           goto dogot;
6424
6425         case R_PPC64_GOT_TPREL16_DS:
6426         case R_PPC64_GOT_TPREL16_LO_DS:
6427         case R_PPC64_GOT_TPREL16_HI:
6428         case R_PPC64_GOT_TPREL16_HA:
6429           tls_type = TLS_TLS | TLS_TPREL;
6430           goto dogot;
6431
6432         case R_PPC64_GOT_DTPREL16_DS:
6433         case R_PPC64_GOT_DTPREL16_LO_DS:
6434         case R_PPC64_GOT_DTPREL16_HI:
6435         case R_PPC64_GOT_DTPREL16_HA:
6436           tls_type = TLS_TLS | TLS_DTPREL;
6437           goto dogot;
6438
6439         case R_PPC64_GOT16:
6440         case R_PPC64_GOT16_DS:
6441         case R_PPC64_GOT16_HA:
6442         case R_PPC64_GOT16_HI:
6443         case R_PPC64_GOT16_LO:
6444         case R_PPC64_GOT16_LO_DS:
6445         dogot:
6446           {
6447             struct got_entry *ent;
6448
6449             if (h != NULL)
6450               ent = h->got.glist;
6451             else
6452               ent = local_got_ents[r_symndx];
6453
6454             for (; ent != NULL; ent = ent->next)
6455               if (ent->addend == rel->r_addend
6456                   && ent->owner == abfd
6457                   && ent->tls_type == tls_type)
6458                 break;
6459             if (ent == NULL)
6460               abort ();
6461             if (ent->got.refcount > 0)
6462               ent->got.refcount -= 1;
6463           }
6464           break;
6465
6466         case R_PPC64_PLT16_HA:
6467         case R_PPC64_PLT16_HI:
6468         case R_PPC64_PLT16_LO:
6469         case R_PPC64_PLT32:
6470         case R_PPC64_PLT64:
6471         case R_PPC64_REL14:
6472         case R_PPC64_REL14_BRNTAKEN:
6473         case R_PPC64_REL14_BRTAKEN:
6474         case R_PPC64_REL24:
6475           if (h != NULL)
6476             {
6477               struct plt_entry *ent;
6478
6479               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6480                 if (ent->addend == rel->r_addend)
6481                   break;
6482               if (ent != NULL && ent->plt.refcount > 0)
6483                 ent->plt.refcount -= 1;
6484             }
6485           break;
6486
6487         default:
6488           break;
6489         }
6490     }
6491   return TRUE;
6492 }
6493
6494 /* The maximum size of .sfpr.  */
6495 #define SFPR_MAX (218*4)
6496
6497 struct sfpr_def_parms
6498 {
6499   const char name[12];
6500   unsigned char lo, hi;
6501   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6502   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6503 };
6504
6505 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6506
6507 static bfd_boolean
6508 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6509 {
6510   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6511   unsigned int i;
6512   size_t len = strlen (parm->name);
6513   bfd_boolean writing = FALSE;
6514   char sym[16];
6515
6516   if (htab == NULL)
6517     return FALSE;
6518
6519   memcpy (sym, parm->name, len);
6520   sym[len + 2] = 0;
6521
6522   for (i = parm->lo; i <= parm->hi; i++)
6523     {
6524       struct elf_link_hash_entry *h;
6525
6526       sym[len + 0] = i / 10 + '0';
6527       sym[len + 1] = i % 10 + '0';
6528       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6529       if (h != NULL
6530           && !h->def_regular)
6531         {
6532           h->root.type = bfd_link_hash_defined;
6533           h->root.u.def.section = htab->sfpr;
6534           h->root.u.def.value = htab->sfpr->size;
6535           h->type = STT_FUNC;
6536           h->def_regular = 1;
6537           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6538           writing = TRUE;
6539           if (htab->sfpr->contents == NULL)
6540             {
6541               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6542               if (htab->sfpr->contents == NULL)
6543                 return FALSE;
6544             }
6545         }
6546       if (writing)
6547         {
6548           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6549           if (i != parm->hi)
6550             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6551           else
6552             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6553           htab->sfpr->size = p - htab->sfpr->contents;
6554         }
6555     }
6556
6557   return TRUE;
6558 }
6559
6560 static bfd_byte *
6561 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6562 {
6563   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6564   return p + 4;
6565 }
6566
6567 static bfd_byte *
6568 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6569 {
6570   p = savegpr0 (abfd, p, r);
6571   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6572   p = p + 4;
6573   bfd_put_32 (abfd, BLR, p);
6574   return p + 4;
6575 }
6576
6577 static bfd_byte *
6578 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6579 {
6580   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6581   return p + 4;
6582 }
6583
6584 static bfd_byte *
6585 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6586 {
6587   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6588   p = p + 4;
6589   p = restgpr0 (abfd, p, r);
6590   bfd_put_32 (abfd, MTLR_R0, p);
6591   p = p + 4;
6592   if (r == 29)
6593     {
6594       p = restgpr0 (abfd, p, 30);
6595       p = restgpr0 (abfd, p, 31);
6596     }
6597   bfd_put_32 (abfd, BLR, p);
6598   return p + 4;
6599 }
6600
6601 static bfd_byte *
6602 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6603 {
6604   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6605   return p + 4;
6606 }
6607
6608 static bfd_byte *
6609 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6610 {
6611   p = savegpr1 (abfd, p, r);
6612   bfd_put_32 (abfd, BLR, p);
6613   return p + 4;
6614 }
6615
6616 static bfd_byte *
6617 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6618 {
6619   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6620   return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6625 {
6626   p = restgpr1 (abfd, p, r);
6627   bfd_put_32 (abfd, BLR, p);
6628   return p + 4;
6629 }
6630
6631 static bfd_byte *
6632 savefpr (bfd *abfd, bfd_byte *p, int r)
6633 {
6634   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   p = savefpr (abfd, p, r);
6642   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6643   p = p + 4;
6644   bfd_put_32 (abfd, BLR, p);
6645   return p + 4;
6646 }
6647
6648 static bfd_byte *
6649 restfpr (bfd *abfd, bfd_byte *p, int r)
6650 {
6651   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6652   return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6657 {
6658   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6659   p = p + 4;
6660   p = restfpr (abfd, p, r);
6661   bfd_put_32 (abfd, MTLR_R0, p);
6662   p = p + 4;
6663   if (r == 29)
6664     {
6665       p = restfpr (abfd, p, 30);
6666       p = restfpr (abfd, p, 31);
6667     }
6668   bfd_put_32 (abfd, BLR, p);
6669   return p + 4;
6670 }
6671
6672 static bfd_byte *
6673 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6674 {
6675   p = savefpr (abfd, p, r);
6676   bfd_put_32 (abfd, BLR, p);
6677   return p + 4;
6678 }
6679
6680 static bfd_byte *
6681 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6682 {
6683   p = restfpr (abfd, p, r);
6684   bfd_put_32 (abfd, BLR, p);
6685   return p + 4;
6686 }
6687
6688 static bfd_byte *
6689 savevr (bfd *abfd, bfd_byte *p, int r)
6690 {
6691   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6692   p = p + 4;
6693   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6694   return p + 4;
6695 }
6696
6697 static bfd_byte *
6698 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6699 {
6700   p = savevr (abfd, p, r);
6701   bfd_put_32 (abfd, BLR, p);
6702   return p + 4;
6703 }
6704
6705 static bfd_byte *
6706 restvr (bfd *abfd, bfd_byte *p, int r)
6707 {
6708   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6709   p = p + 4;
6710   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6711   return p + 4;
6712 }
6713
6714 static bfd_byte *
6715 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6716 {
6717   p = restvr (abfd, p, r);
6718   bfd_put_32 (abfd, BLR, p);
6719   return p + 4;
6720 }
6721
6722 /* Called via elf_link_hash_traverse to transfer dynamic linking
6723    information on function code symbol entries to their corresponding
6724    function descriptor symbol entries.  */
6725
6726 static bfd_boolean
6727 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6728 {
6729   struct bfd_link_info *info;
6730   struct ppc_link_hash_table *htab;
6731   struct plt_entry *ent;
6732   struct ppc_link_hash_entry *fh;
6733   struct ppc_link_hash_entry *fdh;
6734   bfd_boolean force_local;
6735
6736   fh = (struct ppc_link_hash_entry *) h;
6737   if (fh->elf.root.type == bfd_link_hash_indirect)
6738     return TRUE;
6739
6740   info = inf;
6741   htab = ppc_hash_table (info);
6742   if (htab == NULL)
6743     return FALSE;
6744
6745   /* Resolve undefined references to dot-symbols as the value
6746      in the function descriptor, if we have one in a regular object.
6747      This is to satisfy cases like ".quad .foo".  Calls to functions
6748      in dynamic objects are handled elsewhere.  */
6749   if (fh->elf.root.type == bfd_link_hash_undefweak
6750       && fh->was_undefined
6751       && (fdh = defined_func_desc (fh)) != NULL
6752       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6753       && opd_entry_value (fdh->elf.root.u.def.section,
6754                           fdh->elf.root.u.def.value,
6755                           &fh->elf.root.u.def.section,
6756                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6757     {
6758       fh->elf.root.type = fdh->elf.root.type;
6759       fh->elf.forced_local = 1;
6760       fh->elf.def_regular = fdh->elf.def_regular;
6761       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6762     }
6763
6764   /* If this is a function code symbol, transfer dynamic linking
6765      information to the function descriptor symbol.  */
6766   if (!fh->is_func)
6767     return TRUE;
6768
6769   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6770     if (ent->plt.refcount > 0)
6771       break;
6772   if (ent == NULL
6773       || fh->elf.root.root.string[0] != '.'
6774       || fh->elf.root.root.string[1] == '\0')
6775     return TRUE;
6776
6777   /* Find the corresponding function descriptor symbol.  Create it
6778      as undefined if necessary.  */
6779
6780   fdh = lookup_fdh (fh, htab);
6781   if (fdh == NULL
6782       && !info->executable
6783       && (fh->elf.root.type == bfd_link_hash_undefined
6784           || fh->elf.root.type == bfd_link_hash_undefweak))
6785     {
6786       fdh = make_fdh (info, fh);
6787       if (fdh == NULL)
6788         return FALSE;
6789     }
6790
6791   /* Fake function descriptors are made undefweak.  If the function
6792      code symbol is strong undefined, make the fake sym the same.
6793      If the function code symbol is defined, then force the fake
6794      descriptor local;  We can't support overriding of symbols in a
6795      shared library on a fake descriptor.  */
6796
6797   if (fdh != NULL
6798       && fdh->fake
6799       && fdh->elf.root.type == bfd_link_hash_undefweak)
6800     {
6801       if (fh->elf.root.type == bfd_link_hash_undefined)
6802         {
6803           fdh->elf.root.type = bfd_link_hash_undefined;
6804           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6805         }
6806       else if (fh->elf.root.type == bfd_link_hash_defined
6807                || fh->elf.root.type == bfd_link_hash_defweak)
6808         {
6809           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6810         }
6811     }
6812
6813   if (fdh != NULL
6814       && !fdh->elf.forced_local
6815       && (!info->executable
6816           || fdh->elf.def_dynamic
6817           || fdh->elf.ref_dynamic
6818           || (fdh->elf.root.type == bfd_link_hash_undefweak
6819               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6820     {
6821       if (fdh->elf.dynindx == -1)
6822         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6823           return FALSE;
6824       fdh->elf.ref_regular |= fh->elf.ref_regular;
6825       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6826       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6827       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6828       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6829         {
6830           move_plt_plist (fh, fdh);
6831           fdh->elf.needs_plt = 1;
6832         }
6833       fdh->is_func_descriptor = 1;
6834       fdh->oh = fh;
6835       fh->oh = fdh;
6836     }
6837
6838   /* Now that the info is on the function descriptor, clear the
6839      function code sym info.  Any function code syms for which we
6840      don't have a definition in a regular file, we force local.
6841      This prevents a shared library from exporting syms that have
6842      been imported from another library.  Function code syms that
6843      are really in the library we must leave global to prevent the
6844      linker dragging in a definition from a static library.  */
6845   force_local = (!fh->elf.def_regular
6846                  || fdh == NULL
6847                  || !fdh->elf.def_regular
6848                  || fdh->elf.forced_local);
6849   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6850
6851   return TRUE;
6852 }
6853
6854 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6855    this hook to a) provide some gcc support functions, and b) transfer
6856    dynamic linking information gathered so far on function code symbol
6857    entries, to their corresponding function descriptor symbol entries.  */
6858
6859 static bfd_boolean
6860 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6861                             struct bfd_link_info *info)
6862 {
6863   struct ppc_link_hash_table *htab;
6864   unsigned int i;
6865   static const struct sfpr_def_parms funcs[] =
6866     {
6867       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6868       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6869       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6870       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6871       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6872       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6873       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6874       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6875       { "._savef", 14, 31, savefpr, savefpr1_tail },
6876       { "._restf", 14, 31, restfpr, restfpr1_tail },
6877       { "_savevr_", 20, 31, savevr, savevr_tail },
6878       { "_restvr_", 20, 31, restvr, restvr_tail }
6879     };
6880
6881   htab = ppc_hash_table (info);
6882   if (htab == NULL)
6883     return FALSE;
6884
6885   if (!info->relocatable
6886       && htab->elf.hgot != NULL)
6887     {
6888       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6889       /* Make .TOC. defined so as to prevent it being made dynamic.
6890          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6891       htab->elf.hgot->type = STT_OBJECT;
6892       htab->elf.hgot->root.type = bfd_link_hash_defined;
6893       htab->elf.hgot->root.u.def.value = 0;
6894       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6895       htab->elf.hgot->def_regular = 1;
6896       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6897                                | STV_HIDDEN);
6898     }
6899
6900   if (htab->sfpr == NULL)
6901     /* We don't have any relocs.  */
6902     return TRUE;
6903
6904   /* Provide any missing _save* and _rest* functions.  */
6905   htab->sfpr->size = 0;
6906   if (htab->params->save_restore_funcs)
6907     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6908       if (!sfpr_define (info, &funcs[i]))
6909         return FALSE;
6910
6911   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6912
6913   if (htab->sfpr->size == 0)
6914     htab->sfpr->flags |= SEC_EXCLUDE;
6915
6916   return TRUE;
6917 }
6918
6919 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6920
6921 static bfd_boolean
6922 readonly_dynrelocs (struct elf_link_hash_entry *h)
6923 {
6924   struct ppc_link_hash_entry *eh;
6925   struct elf_dyn_relocs *p;
6926
6927   eh = (struct ppc_link_hash_entry *) h;
6928   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6929     {
6930       asection *s = p->sec->output_section;
6931
6932       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6933         return TRUE;
6934     }
6935   return FALSE;
6936 }
6937
6938 /* Adjust a symbol defined by a dynamic object and referenced by a
6939    regular object.  The current definition is in some section of the
6940    dynamic object, but we're not including those sections.  We have to
6941    change the definition to something the rest of the link can
6942    understand.  */
6943
6944 static bfd_boolean
6945 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6946                                  struct elf_link_hash_entry *h)
6947 {
6948   struct ppc_link_hash_table *htab;
6949   asection *s;
6950
6951   htab = ppc_hash_table (info);
6952   if (htab == NULL)
6953     return FALSE;
6954
6955   /* Deal with function syms.  */
6956   if (h->type == STT_FUNC
6957       || h->type == STT_GNU_IFUNC
6958       || h->needs_plt)
6959     {
6960       /* Clear procedure linkage table information for any symbol that
6961          won't need a .plt entry.  */
6962       struct plt_entry *ent;
6963       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6964         if (ent->plt.refcount > 0)
6965           break;
6966       if (ent == NULL
6967           || (h->type != STT_GNU_IFUNC
6968               && (SYMBOL_CALLS_LOCAL (info, h)
6969                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6970                       && h->root.type == bfd_link_hash_undefweak))))
6971         {
6972           h->plt.plist = NULL;
6973           h->needs_plt = 0;
6974         }
6975       else if (abiversion (info->output_bfd) == 2)
6976         {
6977           /* After adjust_dynamic_symbol, non_got_ref set in the
6978              non-shared case means that we have allocated space in
6979              .dynbss for the symbol and thus dyn_relocs for this
6980              symbol should be discarded.
6981              If we get here we know we are making a PLT entry for this
6982              symbol, and in an executable we'd normally resolve
6983              relocations against this symbol to the PLT entry.  Allow
6984              dynamic relocs if the reference is weak, and the dynamic
6985              relocs will not cause text relocation.  */
6986           if (!h->ref_regular_nonweak
6987               && h->non_got_ref
6988               && h->type != STT_GNU_IFUNC
6989               && !readonly_dynrelocs (h))
6990             h->non_got_ref = 0;
6991
6992           /* If making a plt entry, then we don't need copy relocs.  */
6993           return TRUE;
6994         }
6995     }
6996   else
6997     h->plt.plist = NULL;
6998
6999   /* If this is a weak symbol, and there is a real definition, the
7000      processor independent code will have arranged for us to see the
7001      real definition first, and we can just use the same value.  */
7002   if (h->u.weakdef != NULL)
7003     {
7004       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7005                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7006       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7007       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7008       if (ELIMINATE_COPY_RELOCS)
7009         h->non_got_ref = h->u.weakdef->non_got_ref;
7010       return TRUE;
7011     }
7012
7013   /* If we are creating a shared library, we must presume that the
7014      only references to the symbol are via the global offset table.
7015      For such cases we need not do anything here; the relocations will
7016      be handled correctly by relocate_section.  */
7017   if (info->shared)
7018     return TRUE;
7019
7020   /* If there are no references to this symbol that do not use the
7021      GOT, we don't need to generate a copy reloc.  */
7022   if (!h->non_got_ref)
7023     return TRUE;
7024
7025   /* Don't generate a copy reloc for symbols defined in the executable.  */
7026   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7027     return TRUE;
7028
7029   /* If we didn't find any dynamic relocs in read-only sections, then
7030      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7031   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7032     {
7033       h->non_got_ref = 0;
7034       return TRUE;
7035     }
7036
7037   if (h->plt.plist != NULL)
7038     {
7039       /* We should never get here, but unfortunately there are versions
7040          of gcc out there that improperly (for this ABI) put initialized
7041          function pointers, vtable refs and suchlike in read-only
7042          sections.  Allow them to proceed, but warn that this might
7043          break at runtime.  */
7044       info->callbacks->einfo
7045         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7046            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7047          h->root.root.string);
7048     }
7049
7050   /* This is a reference to a symbol defined by a dynamic object which
7051      is not a function.  */
7052
7053   /* We must allocate the symbol in our .dynbss section, which will
7054      become part of the .bss section of the executable.  There will be
7055      an entry for this symbol in the .dynsym section.  The dynamic
7056      object will contain position independent code, so all references
7057      from the dynamic object to this symbol will go through the global
7058      offset table.  The dynamic linker will use the .dynsym entry to
7059      determine the address it must put in the global offset table, so
7060      both the dynamic object and the regular object will refer to the
7061      same memory location for the variable.  */
7062
7063   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7064      to copy the initial value out of the dynamic object and into the
7065      runtime process image.  We need to remember the offset into the
7066      .rela.bss section we are going to use.  */
7067   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7068     {
7069       htab->relbss->size += sizeof (Elf64_External_Rela);
7070       h->needs_copy = 1;
7071     }
7072
7073   s = htab->dynbss;
7074
7075   return _bfd_elf_adjust_dynamic_copy (h, s);
7076 }
7077
7078 /* If given a function descriptor symbol, hide both the function code
7079    sym and the descriptor.  */
7080 static void
7081 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7082                        struct elf_link_hash_entry *h,
7083                        bfd_boolean force_local)
7084 {
7085   struct ppc_link_hash_entry *eh;
7086   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7087
7088   eh = (struct ppc_link_hash_entry *) h;
7089   if (eh->is_func_descriptor)
7090     {
7091       struct ppc_link_hash_entry *fh = eh->oh;
7092
7093       if (fh == NULL)
7094         {
7095           const char *p, *q;
7096           struct ppc_link_hash_table *htab;
7097           char save;
7098
7099           /* We aren't supposed to use alloca in BFD because on
7100              systems which do not have alloca the version in libiberty
7101              calls xmalloc, which might cause the program to crash
7102              when it runs out of memory.  This function doesn't have a
7103              return status, so there's no way to gracefully return an
7104              error.  So cheat.  We know that string[-1] can be safely
7105              accessed;  It's either a string in an ELF string table,
7106              or allocated in an objalloc structure.  */
7107
7108           p = eh->elf.root.root.string - 1;
7109           save = *p;
7110           *(char *) p = '.';
7111           htab = ppc_hash_table (info);
7112           if (htab == NULL)
7113             return;
7114
7115           fh = (struct ppc_link_hash_entry *)
7116             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7117           *(char *) p = save;
7118
7119           /* Unfortunately, if it so happens that the string we were
7120              looking for was allocated immediately before this string,
7121              then we overwrote the string terminator.  That's the only
7122              reason the lookup should fail.  */
7123           if (fh == NULL)
7124             {
7125               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7126               while (q >= eh->elf.root.root.string && *q == *p)
7127                 --q, --p;
7128               if (q < eh->elf.root.root.string && *p == '.')
7129                 fh = (struct ppc_link_hash_entry *)
7130                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7131             }
7132           if (fh != NULL)
7133             {
7134               eh->oh = fh;
7135               fh->oh = eh;
7136             }
7137         }
7138       if (fh != NULL)
7139         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7140     }
7141 }
7142
7143 static bfd_boolean
7144 get_sym_h (struct elf_link_hash_entry **hp,
7145            Elf_Internal_Sym **symp,
7146            asection **symsecp,
7147            unsigned char **tls_maskp,
7148            Elf_Internal_Sym **locsymsp,
7149            unsigned long r_symndx,
7150            bfd *ibfd)
7151 {
7152   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7153
7154   if (r_symndx >= symtab_hdr->sh_info)
7155     {
7156       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7157       struct elf_link_hash_entry *h;
7158
7159       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7160       h = elf_follow_link (h);
7161
7162       if (hp != NULL)
7163         *hp = h;
7164
7165       if (symp != NULL)
7166         *symp = NULL;
7167
7168       if (symsecp != NULL)
7169         {
7170           asection *symsec = NULL;
7171           if (h->root.type == bfd_link_hash_defined
7172               || h->root.type == bfd_link_hash_defweak)
7173             symsec = h->root.u.def.section;
7174           *symsecp = symsec;
7175         }
7176
7177       if (tls_maskp != NULL)
7178         {
7179           struct ppc_link_hash_entry *eh;
7180
7181           eh = (struct ppc_link_hash_entry *) h;
7182           *tls_maskp = &eh->tls_mask;
7183         }
7184     }
7185   else
7186     {
7187       Elf_Internal_Sym *sym;
7188       Elf_Internal_Sym *locsyms = *locsymsp;
7189
7190       if (locsyms == NULL)
7191         {
7192           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7193           if (locsyms == NULL)
7194             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7195                                             symtab_hdr->sh_info,
7196                                             0, NULL, NULL, NULL);
7197           if (locsyms == NULL)
7198             return FALSE;
7199           *locsymsp = locsyms;
7200         }
7201       sym = locsyms + r_symndx;
7202
7203       if (hp != NULL)
7204         *hp = NULL;
7205
7206       if (symp != NULL)
7207         *symp = sym;
7208
7209       if (symsecp != NULL)
7210         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7211
7212       if (tls_maskp != NULL)
7213         {
7214           struct got_entry **lgot_ents;
7215           unsigned char *tls_mask;
7216
7217           tls_mask = NULL;
7218           lgot_ents = elf_local_got_ents (ibfd);
7219           if (lgot_ents != NULL)
7220             {
7221               struct plt_entry **local_plt = (struct plt_entry **)
7222                 (lgot_ents + symtab_hdr->sh_info);
7223               unsigned char *lgot_masks = (unsigned char *)
7224                 (local_plt + symtab_hdr->sh_info);
7225               tls_mask = &lgot_masks[r_symndx];
7226             }
7227           *tls_maskp = tls_mask;
7228         }
7229     }
7230   return TRUE;
7231 }
7232
7233 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7234    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7235    type suitable for optimization, and 1 otherwise.  */
7236
7237 static int
7238 get_tls_mask (unsigned char **tls_maskp,
7239               unsigned long *toc_symndx,
7240               bfd_vma *toc_addend,
7241               Elf_Internal_Sym **locsymsp,
7242               const Elf_Internal_Rela *rel,
7243               bfd *ibfd)
7244 {
7245   unsigned long r_symndx;
7246   int next_r;
7247   struct elf_link_hash_entry *h;
7248   Elf_Internal_Sym *sym;
7249   asection *sec;
7250   bfd_vma off;
7251
7252   r_symndx = ELF64_R_SYM (rel->r_info);
7253   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7254     return 0;
7255
7256   if ((*tls_maskp != NULL && **tls_maskp != 0)
7257       || sec == NULL
7258       || ppc64_elf_section_data (sec) == NULL
7259       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7260     return 1;
7261
7262   /* Look inside a TOC section too.  */
7263   if (h != NULL)
7264     {
7265       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7266       off = h->root.u.def.value;
7267     }
7268   else
7269     off = sym->st_value;
7270   off += rel->r_addend;
7271   BFD_ASSERT (off % 8 == 0);
7272   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7273   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7274   if (toc_symndx != NULL)
7275     *toc_symndx = r_symndx;
7276   if (toc_addend != NULL)
7277     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7278   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7279     return 0;
7280   if ((h == NULL || is_static_defined (h))
7281       && (next_r == -1 || next_r == -2))
7282     return 1 - next_r;
7283   return 1;
7284 }
7285
7286 /* Find (or create) an entry in the tocsave hash table.  */
7287
7288 static struct tocsave_entry *
7289 tocsave_find (struct ppc_link_hash_table *htab,
7290               enum insert_option insert,
7291               Elf_Internal_Sym **local_syms,
7292               const Elf_Internal_Rela *irela,
7293               bfd *ibfd)
7294 {
7295   unsigned long r_indx;
7296   struct elf_link_hash_entry *h;
7297   Elf_Internal_Sym *sym;
7298   struct tocsave_entry ent, *p;
7299   hashval_t hash;
7300   struct tocsave_entry **slot;
7301
7302   r_indx = ELF64_R_SYM (irela->r_info);
7303   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7304     return NULL;
7305   if (ent.sec == NULL || ent.sec->output_section == NULL)
7306     {
7307       (*_bfd_error_handler)
7308         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7309       return NULL;
7310     }
7311
7312   if (h != NULL)
7313     ent.offset = h->root.u.def.value;
7314   else
7315     ent.offset = sym->st_value;
7316   ent.offset += irela->r_addend;
7317
7318   hash = tocsave_htab_hash (&ent);
7319   slot = ((struct tocsave_entry **)
7320           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7321   if (slot == NULL)
7322     return NULL;
7323
7324   if (*slot == NULL)
7325     {
7326       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7327       if (p == NULL)
7328         return NULL;
7329       *p = ent;
7330       *slot = p;
7331     }
7332   return *slot;
7333 }
7334
7335 /* Adjust all global syms defined in opd sections.  In gcc generated
7336    code for the old ABI, these will already have been done.  */
7337
7338 static bfd_boolean
7339 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7340 {
7341   struct ppc_link_hash_entry *eh;
7342   asection *sym_sec;
7343   struct _opd_sec_data *opd;
7344
7345   if (h->root.type == bfd_link_hash_indirect)
7346     return TRUE;
7347
7348   if (h->root.type != bfd_link_hash_defined
7349       && h->root.type != bfd_link_hash_defweak)
7350     return TRUE;
7351
7352   eh = (struct ppc_link_hash_entry *) h;
7353   if (eh->adjust_done)
7354     return TRUE;
7355
7356   sym_sec = eh->elf.root.u.def.section;
7357   opd = get_opd_info (sym_sec);
7358   if (opd != NULL && opd->adjust != NULL)
7359     {
7360       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7361       if (adjust == -1)
7362         {
7363           /* This entry has been deleted.  */
7364           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7365           if (dsec == NULL)
7366             {
7367               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7368                 if (discarded_section (dsec))
7369                   {
7370                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7371                     break;
7372                   }
7373             }
7374           eh->elf.root.u.def.value = 0;
7375           eh->elf.root.u.def.section = dsec;
7376         }
7377       else
7378         eh->elf.root.u.def.value += adjust;
7379       eh->adjust_done = 1;
7380     }
7381   return TRUE;
7382 }
7383
7384 /* Handles decrementing dynamic reloc counts for the reloc specified by
7385    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7386    have already been determined.  */
7387
7388 static bfd_boolean
7389 dec_dynrel_count (bfd_vma r_info,
7390                   asection *sec,
7391                   struct bfd_link_info *info,
7392                   Elf_Internal_Sym **local_syms,
7393                   struct elf_link_hash_entry *h,
7394                   Elf_Internal_Sym *sym)
7395 {
7396   enum elf_ppc64_reloc_type r_type;
7397   asection *sym_sec = NULL;
7398
7399   /* Can this reloc be dynamic?  This switch, and later tests here
7400      should be kept in sync with the code in check_relocs.  */
7401   r_type = ELF64_R_TYPE (r_info);
7402   switch (r_type)
7403     {
7404     default:
7405       return TRUE;
7406
7407     case R_PPC64_TPREL16:
7408     case R_PPC64_TPREL16_LO:
7409     case R_PPC64_TPREL16_HI:
7410     case R_PPC64_TPREL16_HA:
7411     case R_PPC64_TPREL16_DS:
7412     case R_PPC64_TPREL16_LO_DS:
7413     case R_PPC64_TPREL16_HIGH:
7414     case R_PPC64_TPREL16_HIGHA:
7415     case R_PPC64_TPREL16_HIGHER:
7416     case R_PPC64_TPREL16_HIGHERA:
7417     case R_PPC64_TPREL16_HIGHEST:
7418     case R_PPC64_TPREL16_HIGHESTA:
7419       if (!info->shared)
7420         return TRUE;
7421
7422     case R_PPC64_TPREL64:
7423     case R_PPC64_DTPMOD64:
7424     case R_PPC64_DTPREL64:
7425     case R_PPC64_ADDR64:
7426     case R_PPC64_REL30:
7427     case R_PPC64_REL32:
7428     case R_PPC64_REL64:
7429     case R_PPC64_ADDR14:
7430     case R_PPC64_ADDR14_BRNTAKEN:
7431     case R_PPC64_ADDR14_BRTAKEN:
7432     case R_PPC64_ADDR16:
7433     case R_PPC64_ADDR16_DS:
7434     case R_PPC64_ADDR16_HA:
7435     case R_PPC64_ADDR16_HI:
7436     case R_PPC64_ADDR16_HIGH:
7437     case R_PPC64_ADDR16_HIGHA:
7438     case R_PPC64_ADDR16_HIGHER:
7439     case R_PPC64_ADDR16_HIGHERA:
7440     case R_PPC64_ADDR16_HIGHEST:
7441     case R_PPC64_ADDR16_HIGHESTA:
7442     case R_PPC64_ADDR16_LO:
7443     case R_PPC64_ADDR16_LO_DS:
7444     case R_PPC64_ADDR24:
7445     case R_PPC64_ADDR32:
7446     case R_PPC64_UADDR16:
7447     case R_PPC64_UADDR32:
7448     case R_PPC64_UADDR64:
7449     case R_PPC64_TOC:
7450       break;
7451     }
7452
7453   if (local_syms != NULL)
7454     {
7455       unsigned long r_symndx;
7456       bfd *ibfd = sec->owner;
7457
7458       r_symndx = ELF64_R_SYM (r_info);
7459       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7460         return FALSE;
7461     }
7462
7463   if ((info->shared
7464        && (must_be_dyn_reloc (info, r_type)
7465            || (h != NULL
7466                && (!SYMBOLIC_BIND (info, h)
7467                    || h->root.type == bfd_link_hash_defweak
7468                    || !h->def_regular))))
7469       || (ELIMINATE_COPY_RELOCS
7470           && !info->shared
7471           && h != NULL
7472           && (h->root.type == bfd_link_hash_defweak
7473               || !h->def_regular)))
7474     ;
7475   else
7476     return TRUE;
7477
7478   if (h != NULL)
7479     {
7480       struct elf_dyn_relocs *p;
7481       struct elf_dyn_relocs **pp;
7482       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7483
7484       /* elf_gc_sweep may have already removed all dyn relocs associated
7485          with local syms for a given section.  Also, symbol flags are
7486          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7487          report a dynreloc miscount.  */
7488       if (*pp == NULL && info->gc_sections)
7489         return TRUE;
7490
7491       while ((p = *pp) != NULL)
7492         {
7493           if (p->sec == sec)
7494             {
7495               if (!must_be_dyn_reloc (info, r_type))
7496                 p->pc_count -= 1;
7497               p->count -= 1;
7498               if (p->count == 0)
7499                 *pp = p->next;
7500               return TRUE;
7501             }
7502           pp = &p->next;
7503         }
7504     }
7505   else
7506     {
7507       struct ppc_dyn_relocs *p;
7508       struct ppc_dyn_relocs **pp;
7509       void *vpp;
7510       bfd_boolean is_ifunc;
7511
7512       if (local_syms == NULL)
7513         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7514       if (sym_sec == NULL)
7515         sym_sec = sec;
7516
7517       vpp = &elf_section_data (sym_sec)->local_dynrel;
7518       pp = (struct ppc_dyn_relocs **) vpp;
7519
7520       if (*pp == NULL && info->gc_sections)
7521         return TRUE;
7522
7523       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7524       while ((p = *pp) != NULL)
7525         {
7526           if (p->sec == sec && p->ifunc == is_ifunc)
7527             {
7528               p->count -= 1;
7529               if (p->count == 0)
7530                 *pp = p->next;
7531               return TRUE;
7532             }
7533           pp = &p->next;
7534         }
7535     }
7536
7537   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7538                           sec->owner, sec);
7539   bfd_set_error (bfd_error_bad_value);
7540   return FALSE;
7541 }
7542
7543 /* Remove unused Official Procedure Descriptor entries.  Currently we
7544    only remove those associated with functions in discarded link-once
7545    sections, or weakly defined functions that have been overridden.  It
7546    would be possible to remove many more entries for statically linked
7547    applications.  */
7548
7549 bfd_boolean
7550 ppc64_elf_edit_opd (struct bfd_link_info *info)
7551 {
7552   bfd *ibfd;
7553   bfd_boolean some_edited = FALSE;
7554   asection *need_pad = NULL;
7555   struct ppc_link_hash_table *htab;
7556
7557   htab = ppc_hash_table (info);
7558   if (htab == NULL)
7559     return FALSE;
7560
7561   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7562     {
7563       asection *sec;
7564       Elf_Internal_Rela *relstart, *rel, *relend;
7565       Elf_Internal_Shdr *symtab_hdr;
7566       Elf_Internal_Sym *local_syms;
7567       bfd_vma offset;
7568       struct _opd_sec_data *opd;
7569       bfd_boolean need_edit, add_aux_fields;
7570       bfd_size_type cnt_16b = 0;
7571
7572       if (!is_ppc64_elf (ibfd))
7573         continue;
7574
7575       sec = bfd_get_section_by_name (ibfd, ".opd");
7576       if (sec == NULL || sec->size == 0)
7577         continue;
7578
7579       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7580         continue;
7581
7582       if (sec->output_section == bfd_abs_section_ptr)
7583         continue;
7584
7585       /* Look through the section relocs.  */
7586       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7587         continue;
7588
7589       local_syms = NULL;
7590       symtab_hdr = &elf_symtab_hdr (ibfd);
7591
7592       /* Read the relocations.  */
7593       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7594                                             info->keep_memory);
7595       if (relstart == NULL)
7596         return FALSE;
7597
7598       /* First run through the relocs to check they are sane, and to
7599          determine whether we need to edit this opd section.  */
7600       need_edit = FALSE;
7601       need_pad = sec;
7602       offset = 0;
7603       relend = relstart + sec->reloc_count;
7604       for (rel = relstart; rel < relend; )
7605         {
7606           enum elf_ppc64_reloc_type r_type;
7607           unsigned long r_symndx;
7608           asection *sym_sec;
7609           struct elf_link_hash_entry *h;
7610           Elf_Internal_Sym *sym;
7611
7612           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7613              only interested in the reloc pointing to a function entry
7614              point.  */
7615           if (rel->r_offset != offset
7616               || rel + 1 >= relend
7617               || (rel + 1)->r_offset != offset + 8)
7618             {
7619               /* If someone messes with .opd alignment then after a
7620                  "ld -r" we might have padding in the middle of .opd.
7621                  Also, there's nothing to prevent someone putting
7622                  something silly in .opd with the assembler.  No .opd
7623                  optimization for them!  */
7624             broken_opd:
7625               (*_bfd_error_handler)
7626                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7627               need_edit = FALSE;
7628               break;
7629             }
7630
7631           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7632               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7633             {
7634               (*_bfd_error_handler)
7635                 (_("%B: unexpected reloc type %u in .opd section"),
7636                  ibfd, r_type);
7637               need_edit = FALSE;
7638               break;
7639             }
7640
7641           r_symndx = ELF64_R_SYM (rel->r_info);
7642           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7643                           r_symndx, ibfd))
7644             goto error_ret;
7645
7646           if (sym_sec == NULL || sym_sec->owner == NULL)
7647             {
7648               const char *sym_name;
7649               if (h != NULL)
7650                 sym_name = h->root.root.string;
7651               else
7652                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7653                                              sym_sec);
7654
7655               (*_bfd_error_handler)
7656                 (_("%B: undefined sym `%s' in .opd section"),
7657                  ibfd, sym_name);
7658               need_edit = FALSE;
7659               break;
7660             }
7661
7662           /* opd entries are always for functions defined in the
7663              current input bfd.  If the symbol isn't defined in the
7664              input bfd, then we won't be using the function in this
7665              bfd;  It must be defined in a linkonce section in another
7666              bfd, or is weak.  It's also possible that we are
7667              discarding the function due to a linker script /DISCARD/,
7668              which we test for via the output_section.  */
7669           if (sym_sec->owner != ibfd
7670               || sym_sec->output_section == bfd_abs_section_ptr)
7671             need_edit = TRUE;
7672
7673           rel += 2;
7674           if (rel == relend
7675               || (rel + 1 == relend && rel->r_offset == offset + 16))
7676             {
7677               if (sec->size == offset + 24)
7678                 {
7679                   need_pad = NULL;
7680                   break;
7681                 }
7682               if (rel == relend && sec->size == offset + 16)
7683                 {
7684                   cnt_16b++;
7685                   break;
7686                 }
7687               goto broken_opd;
7688             }
7689
7690           if (rel->r_offset == offset + 24)
7691             offset += 24;
7692           else if (rel->r_offset != offset + 16)
7693             goto broken_opd;
7694           else if (rel + 1 < relend
7695                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7696                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7697             {
7698               offset += 16;
7699               cnt_16b++;
7700             }
7701           else if (rel + 2 < relend
7702                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7703                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7704             {
7705               offset += 24;
7706               rel += 1;
7707             }
7708           else
7709             goto broken_opd;
7710         }
7711
7712       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7713
7714       if (need_edit || add_aux_fields)
7715         {
7716           Elf_Internal_Rela *write_rel;
7717           Elf_Internal_Shdr *rel_hdr;
7718           bfd_byte *rptr, *wptr;
7719           bfd_byte *new_contents;
7720           bfd_boolean skip;
7721           long opd_ent_size;
7722           bfd_size_type amt;
7723
7724           new_contents = NULL;
7725           amt = sec->size * sizeof (long) / 8;
7726           opd = &ppc64_elf_section_data (sec)->u.opd;
7727           opd->adjust = bfd_zalloc (sec->owner, amt);
7728           if (opd->adjust == NULL)
7729             return FALSE;
7730           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7731
7732           /* This seems a waste of time as input .opd sections are all
7733              zeros as generated by gcc, but I suppose there's no reason
7734              this will always be so.  We might start putting something in
7735              the third word of .opd entries.  */
7736           if ((sec->flags & SEC_IN_MEMORY) == 0)
7737             {
7738               bfd_byte *loc;
7739               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7740                 {
7741                   if (loc != NULL)
7742                     free (loc);
7743                 error_ret:
7744                   if (local_syms != NULL
7745                       && symtab_hdr->contents != (unsigned char *) local_syms)
7746                     free (local_syms);
7747                   if (elf_section_data (sec)->relocs != relstart)
7748                     free (relstart);
7749                   return FALSE;
7750                 }
7751               sec->contents = loc;
7752               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7753             }
7754
7755           elf_section_data (sec)->relocs = relstart;
7756
7757           new_contents = sec->contents;
7758           if (add_aux_fields)
7759             {
7760               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7761               if (new_contents == NULL)
7762                 return FALSE;
7763               need_pad = FALSE;
7764             }
7765           wptr = new_contents;
7766           rptr = sec->contents;
7767
7768           write_rel = relstart;
7769           skip = FALSE;
7770           offset = 0;
7771           opd_ent_size = 0;
7772           for (rel = relstart; rel < relend; rel++)
7773             {
7774               unsigned long r_symndx;
7775               asection *sym_sec;
7776               struct elf_link_hash_entry *h;
7777               Elf_Internal_Sym *sym;
7778
7779               r_symndx = ELF64_R_SYM (rel->r_info);
7780               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7781                               r_symndx, ibfd))
7782                 goto error_ret;
7783
7784               if (rel->r_offset == offset)
7785                 {
7786                   struct ppc_link_hash_entry *fdh = NULL;
7787
7788                   /* See if the .opd entry is full 24 byte or
7789                      16 byte (with fd_aux entry overlapped with next
7790                      fd_func).  */
7791                   opd_ent_size = 24;
7792                   if ((rel + 2 == relend && sec->size == offset + 16)
7793                       || (rel + 3 < relend
7794                           && rel[2].r_offset == offset + 16
7795                           && rel[3].r_offset == offset + 24
7796                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7797                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7798                     opd_ent_size = 16;
7799
7800                   if (h != NULL
7801                       && h->root.root.string[0] == '.')
7802                     {
7803                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7804                       if (fdh != NULL
7805                           && fdh->elf.root.type != bfd_link_hash_defined
7806                           && fdh->elf.root.type != bfd_link_hash_defweak)
7807                         fdh = NULL;
7808                     }
7809
7810                   skip = (sym_sec->owner != ibfd
7811                           || sym_sec->output_section == bfd_abs_section_ptr);
7812                   if (skip)
7813                     {
7814                       if (fdh != NULL && sym_sec->owner == ibfd)
7815                         {
7816                           /* Arrange for the function descriptor sym
7817                              to be dropped.  */
7818                           fdh->elf.root.u.def.value = 0;
7819                           fdh->elf.root.u.def.section = sym_sec;
7820                         }
7821                       opd->adjust[rel->r_offset / 8] = -1;
7822                     }
7823                   else
7824                     {
7825                       /* We'll be keeping this opd entry.  */
7826
7827                       if (fdh != NULL)
7828                         {
7829                           /* Redefine the function descriptor symbol to
7830                              this location in the opd section.  It is
7831                              necessary to update the value here rather
7832                              than using an array of adjustments as we do
7833                              for local symbols, because various places
7834                              in the generic ELF code use the value
7835                              stored in u.def.value.  */
7836                           fdh->elf.root.u.def.value = wptr - new_contents;
7837                           fdh->adjust_done = 1;
7838                         }
7839
7840                       /* Local syms are a bit tricky.  We could
7841                          tweak them as they can be cached, but
7842                          we'd need to look through the local syms
7843                          for the function descriptor sym which we
7844                          don't have at the moment.  So keep an
7845                          array of adjustments.  */
7846                       opd->adjust[rel->r_offset / 8]
7847                         = (wptr - new_contents) - (rptr - sec->contents);
7848
7849                       if (wptr != rptr)
7850                         memcpy (wptr, rptr, opd_ent_size);
7851                       wptr += opd_ent_size;
7852                       if (add_aux_fields && opd_ent_size == 16)
7853                         {
7854                           memset (wptr, '\0', 8);
7855                           wptr += 8;
7856                         }
7857                     }
7858                   rptr += opd_ent_size;
7859                   offset += opd_ent_size;
7860                 }
7861
7862               if (skip)
7863                 {
7864                   if (!NO_OPD_RELOCS
7865                       && !info->relocatable
7866                       && !dec_dynrel_count (rel->r_info, sec, info,
7867                                             NULL, h, sym))
7868                     goto error_ret;
7869                 }
7870               else
7871                 {
7872                   /* We need to adjust any reloc offsets to point to the
7873                      new opd entries.  While we're at it, we may as well
7874                      remove redundant relocs.  */
7875                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7876                   if (write_rel != rel)
7877                     memcpy (write_rel, rel, sizeof (*rel));
7878                   ++write_rel;
7879                 }
7880             }
7881
7882           sec->size = wptr - new_contents;
7883           sec->reloc_count = write_rel - relstart;
7884           if (add_aux_fields)
7885             {
7886               free (sec->contents);
7887               sec->contents = new_contents;
7888             }
7889
7890           /* Fudge the header size too, as this is used later in
7891              elf_bfd_final_link if we are emitting relocs.  */
7892           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7893           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7894           some_edited = TRUE;
7895         }
7896       else if (elf_section_data (sec)->relocs != relstart)
7897         free (relstart);
7898
7899       if (local_syms != NULL
7900           && symtab_hdr->contents != (unsigned char *) local_syms)
7901         {
7902           if (!info->keep_memory)
7903             free (local_syms);
7904           else
7905             symtab_hdr->contents = (unsigned char *) local_syms;
7906         }
7907     }
7908
7909   if (some_edited)
7910     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7911
7912   /* If we are doing a final link and the last .opd entry is just 16 byte
7913      long, add a 8 byte padding after it.  */
7914   if (need_pad != NULL && !info->relocatable)
7915     {
7916       bfd_byte *p;
7917
7918       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7919         {
7920           BFD_ASSERT (need_pad->size > 0);
7921
7922           p = bfd_malloc (need_pad->size + 8);
7923           if (p == NULL)
7924             return FALSE;
7925
7926           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7927                                           p, 0, need_pad->size))
7928             return FALSE;
7929
7930           need_pad->contents = p;
7931           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7932         }
7933       else
7934         {
7935           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7936           if (p == NULL)
7937             return FALSE;
7938
7939           need_pad->contents = p;
7940         }
7941
7942       memset (need_pad->contents + need_pad->size, 0, 8);
7943       need_pad->size += 8;
7944     }
7945
7946   return TRUE;
7947 }
7948
7949 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7950
7951 asection *
7952 ppc64_elf_tls_setup (struct bfd_link_info *info)
7953 {
7954   struct ppc_link_hash_table *htab;
7955
7956   htab = ppc_hash_table (info);
7957   if (htab == NULL)
7958     return NULL;
7959
7960   if (abiversion (info->output_bfd) == 1)
7961     htab->opd_abi = 1;
7962
7963   if (htab->params->no_multi_toc)
7964     htab->do_multi_toc = 0;
7965   else if (!htab->do_multi_toc)
7966     htab->params->no_multi_toc = 1;
7967
7968   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7969                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7970                                               FALSE, FALSE, TRUE));
7971   /* Move dynamic linking info to the function descriptor sym.  */
7972   if (htab->tls_get_addr != NULL)
7973     func_desc_adjust (&htab->tls_get_addr->elf, info);
7974   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7975                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7976                                                  FALSE, FALSE, TRUE));
7977   if (!htab->params->no_tls_get_addr_opt)
7978     {
7979       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7980
7981       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7982                                   FALSE, FALSE, TRUE);
7983       if (opt != NULL)
7984         func_desc_adjust (opt, info);
7985       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7986                                      FALSE, FALSE, TRUE);
7987       if (opt_fd != NULL
7988           && (opt_fd->root.type == bfd_link_hash_defined
7989               || opt_fd->root.type == bfd_link_hash_defweak))
7990         {
7991           /* If glibc supports an optimized __tls_get_addr call stub,
7992              signalled by the presence of __tls_get_addr_opt, and we'll
7993              be calling __tls_get_addr via a plt call stub, then
7994              make __tls_get_addr point to __tls_get_addr_opt.  */
7995           tga_fd = &htab->tls_get_addr_fd->elf;
7996           if (htab->elf.dynamic_sections_created
7997               && tga_fd != NULL
7998               && (tga_fd->type == STT_FUNC
7999                   || tga_fd->needs_plt)
8000               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8001                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8002                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8003             {
8004               struct plt_entry *ent;
8005
8006               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8007                 if (ent->plt.refcount > 0)
8008                   break;
8009               if (ent != NULL)
8010                 {
8011                   tga_fd->root.type = bfd_link_hash_indirect;
8012                   tga_fd->root.u.i.link = &opt_fd->root;
8013                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8014                   if (opt_fd->dynindx != -1)
8015                     {
8016                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8017                       opt_fd->dynindx = -1;
8018                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8019                                               opt_fd->dynstr_index);
8020                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8021                         return NULL;
8022                     }
8023                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8024                   tga = &htab->tls_get_addr->elf;
8025                   if (opt != NULL && tga != NULL)
8026                     {
8027                       tga->root.type = bfd_link_hash_indirect;
8028                       tga->root.u.i.link = &opt->root;
8029                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8030                       _bfd_elf_link_hash_hide_symbol (info, opt,
8031                                                       tga->forced_local);
8032                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8033                     }
8034                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8035                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8036                   if (htab->tls_get_addr != NULL)
8037                     {
8038                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8039                       htab->tls_get_addr->is_func = 1;
8040                     }
8041                 }
8042             }
8043         }
8044       else
8045         htab->params->no_tls_get_addr_opt = TRUE;
8046     }
8047   return _bfd_elf_tls_setup (info->output_bfd, info);
8048 }
8049
8050 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8051    HASH1 or HASH2.  */
8052
8053 static bfd_boolean
8054 branch_reloc_hash_match (const bfd *ibfd,
8055                          const Elf_Internal_Rela *rel,
8056                          const struct ppc_link_hash_entry *hash1,
8057                          const struct ppc_link_hash_entry *hash2)
8058 {
8059   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8060   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8061   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8062
8063   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8064     {
8065       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8066       struct elf_link_hash_entry *h;
8067
8068       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8069       h = elf_follow_link (h);
8070       if (h == &hash1->elf || h == &hash2->elf)
8071         return TRUE;
8072     }
8073   return FALSE;
8074 }
8075
8076 /* Run through all the TLS relocs looking for optimization
8077    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8078    a preliminary section layout so that we know the TLS segment
8079    offsets.  We can't optimize earlier because some optimizations need
8080    to know the tp offset, and we need to optimize before allocating
8081    dynamic relocations.  */
8082
8083 bfd_boolean
8084 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8085 {
8086   bfd *ibfd;
8087   asection *sec;
8088   struct ppc_link_hash_table *htab;
8089   unsigned char *toc_ref;
8090   int pass;
8091
8092   if (info->relocatable || !info->executable)
8093     return TRUE;
8094
8095   htab = ppc_hash_table (info);
8096   if (htab == NULL)
8097     return FALSE;
8098
8099   /* Make two passes over the relocs.  On the first pass, mark toc
8100      entries involved with tls relocs, and check that tls relocs
8101      involved in setting up a tls_get_addr call are indeed followed by
8102      such a call.  If they are not, we can't do any tls optimization.
8103      On the second pass twiddle tls_mask flags to notify
8104      relocate_section that optimization can be done, and adjust got
8105      and plt refcounts.  */
8106   toc_ref = NULL;
8107   for (pass = 0; pass < 2; ++pass)
8108     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8109       {
8110         Elf_Internal_Sym *locsyms = NULL;
8111         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8112
8113         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8114           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8115             {
8116               Elf_Internal_Rela *relstart, *rel, *relend;
8117               bfd_boolean found_tls_get_addr_arg = 0;
8118
8119               /* Read the relocations.  */
8120               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8121                                                     info->keep_memory);
8122               if (relstart == NULL)
8123                 {
8124                   free (toc_ref);
8125                   return FALSE;
8126                 }
8127
8128               relend = relstart + sec->reloc_count;
8129               for (rel = relstart; rel < relend; rel++)
8130                 {
8131                   enum elf_ppc64_reloc_type r_type;
8132                   unsigned long r_symndx;
8133                   struct elf_link_hash_entry *h;
8134                   Elf_Internal_Sym *sym;
8135                   asection *sym_sec;
8136                   unsigned char *tls_mask;
8137                   unsigned char tls_set, tls_clear, tls_type = 0;
8138                   bfd_vma value;
8139                   bfd_boolean ok_tprel, is_local;
8140                   long toc_ref_index = 0;
8141                   int expecting_tls_get_addr = 0;
8142                   bfd_boolean ret = FALSE;
8143
8144                   r_symndx = ELF64_R_SYM (rel->r_info);
8145                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8146                                   r_symndx, ibfd))
8147                     {
8148                     err_free_rel:
8149                       if (elf_section_data (sec)->relocs != relstart)
8150                         free (relstart);
8151                       if (toc_ref != NULL)
8152                         free (toc_ref);
8153                       if (locsyms != NULL
8154                           && (elf_symtab_hdr (ibfd).contents
8155                               != (unsigned char *) locsyms))
8156                         free (locsyms);
8157                       return ret;
8158                     }
8159
8160                   if (h != NULL)
8161                     {
8162                       if (h->root.type == bfd_link_hash_defined
8163                           || h->root.type == bfd_link_hash_defweak)
8164                         value = h->root.u.def.value;
8165                       else if (h->root.type == bfd_link_hash_undefweak)
8166                         value = 0;
8167                       else
8168                         {
8169                           found_tls_get_addr_arg = 0;
8170                           continue;
8171                         }
8172                     }
8173                   else
8174                     /* Symbols referenced by TLS relocs must be of type
8175                        STT_TLS.  So no need for .opd local sym adjust.  */
8176                     value = sym->st_value;
8177
8178                   ok_tprel = FALSE;
8179                   is_local = FALSE;
8180                   if (h == NULL
8181                       || !h->def_dynamic)
8182                     {
8183                       is_local = TRUE;
8184                       if (h != NULL
8185                           && h->root.type == bfd_link_hash_undefweak)
8186                         ok_tprel = TRUE;
8187                       else
8188                         {
8189                           value += sym_sec->output_offset;
8190                           value += sym_sec->output_section->vma;
8191                           value -= htab->elf.tls_sec->vma;
8192                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8193                                       < (bfd_vma) 1 << 32);
8194                         }
8195                     }
8196
8197                   r_type = ELF64_R_TYPE (rel->r_info);
8198                   /* If this section has old-style __tls_get_addr calls
8199                      without marker relocs, then check that each
8200                      __tls_get_addr call reloc is preceded by a reloc
8201                      that conceivably belongs to the __tls_get_addr arg
8202                      setup insn.  If we don't find matching arg setup
8203                      relocs, don't do any tls optimization.  */
8204                   if (pass == 0
8205                       && sec->has_tls_get_addr_call
8206                       && h != NULL
8207                       && (h == &htab->tls_get_addr->elf
8208                           || h == &htab->tls_get_addr_fd->elf)
8209                       && !found_tls_get_addr_arg
8210                       && is_branch_reloc (r_type))
8211                     {
8212                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8213                                                 "TLS optimization disabled\n"),
8214                                               ibfd, sec, rel->r_offset);
8215                       ret = TRUE;
8216                       goto err_free_rel;
8217                     }
8218
8219                   found_tls_get_addr_arg = 0;
8220                   switch (r_type)
8221                     {
8222                     case R_PPC64_GOT_TLSLD16:
8223                     case R_PPC64_GOT_TLSLD16_LO:
8224                       expecting_tls_get_addr = 1;
8225                       found_tls_get_addr_arg = 1;
8226                       /* Fall thru */
8227
8228                     case R_PPC64_GOT_TLSLD16_HI:
8229                     case R_PPC64_GOT_TLSLD16_HA:
8230                       /* These relocs should never be against a symbol
8231                          defined in a shared lib.  Leave them alone if
8232                          that turns out to be the case.  */
8233                       if (!is_local)
8234                         continue;
8235
8236                       /* LD -> LE */
8237                       tls_set = 0;
8238                       tls_clear = TLS_LD;
8239                       tls_type = TLS_TLS | TLS_LD;
8240                       break;
8241
8242                     case R_PPC64_GOT_TLSGD16:
8243                     case R_PPC64_GOT_TLSGD16_LO:
8244                       expecting_tls_get_addr = 1;
8245                       found_tls_get_addr_arg = 1;
8246                       /* Fall thru */
8247
8248                     case R_PPC64_GOT_TLSGD16_HI:
8249                     case R_PPC64_GOT_TLSGD16_HA:
8250                       if (ok_tprel)
8251                         /* GD -> LE */
8252                         tls_set = 0;
8253                       else
8254                         /* GD -> IE */
8255                         tls_set = TLS_TLS | TLS_TPRELGD;
8256                       tls_clear = TLS_GD;
8257                       tls_type = TLS_TLS | TLS_GD;
8258                       break;
8259
8260                     case R_PPC64_GOT_TPREL16_DS:
8261                     case R_PPC64_GOT_TPREL16_LO_DS:
8262                     case R_PPC64_GOT_TPREL16_HI:
8263                     case R_PPC64_GOT_TPREL16_HA:
8264                       if (ok_tprel)
8265                         {
8266                           /* IE -> LE */
8267                           tls_set = 0;
8268                           tls_clear = TLS_TPREL;
8269                           tls_type = TLS_TLS | TLS_TPREL;
8270                           break;
8271                         }
8272                       continue;
8273
8274                     case R_PPC64_TLSGD:
8275                     case R_PPC64_TLSLD:
8276                       found_tls_get_addr_arg = 1;
8277                       /* Fall thru */
8278
8279                     case R_PPC64_TLS:
8280                     case R_PPC64_TOC16:
8281                     case R_PPC64_TOC16_LO:
8282                       if (sym_sec == NULL || sym_sec != toc)
8283                         continue;
8284
8285                       /* Mark this toc entry as referenced by a TLS
8286                          code sequence.  We can do that now in the
8287                          case of R_PPC64_TLS, and after checking for
8288                          tls_get_addr for the TOC16 relocs.  */
8289                       if (toc_ref == NULL)
8290                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8291                       if (toc_ref == NULL)
8292                         goto err_free_rel;
8293
8294                       if (h != NULL)
8295                         value = h->root.u.def.value;
8296                       else
8297                         value = sym->st_value;
8298                       value += rel->r_addend;
8299                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8300                       toc_ref_index = (value + toc->output_offset) / 8;
8301                       if (r_type == R_PPC64_TLS
8302                           || r_type == R_PPC64_TLSGD
8303                           || r_type == R_PPC64_TLSLD)
8304                         {
8305                           toc_ref[toc_ref_index] = 1;
8306                           continue;
8307                         }
8308
8309                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8310                         continue;
8311
8312                       tls_set = 0;
8313                       tls_clear = 0;
8314                       expecting_tls_get_addr = 2;
8315                       break;
8316
8317                     case R_PPC64_TPREL64:
8318                       if (pass == 0
8319                           || sec != toc
8320                           || toc_ref == NULL
8321                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8322                         continue;
8323                       if (ok_tprel)
8324                         {
8325                           /* IE -> LE */
8326                           tls_set = TLS_EXPLICIT;
8327                           tls_clear = TLS_TPREL;
8328                           break;
8329                         }
8330                       continue;
8331
8332                     case R_PPC64_DTPMOD64:
8333                       if (pass == 0
8334                           || sec != toc
8335                           || toc_ref == NULL
8336                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8337                         continue;
8338                       if (rel + 1 < relend
8339                           && (rel[1].r_info
8340                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8341                           && rel[1].r_offset == rel->r_offset + 8)
8342                         {
8343                           if (ok_tprel)
8344                             /* GD -> LE */
8345                             tls_set = TLS_EXPLICIT | TLS_GD;
8346                           else
8347                             /* GD -> IE */
8348                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8349                           tls_clear = TLS_GD;
8350                         }
8351                       else
8352                         {
8353                           if (!is_local)
8354                             continue;
8355
8356                           /* LD -> LE */
8357                           tls_set = TLS_EXPLICIT;
8358                           tls_clear = TLS_LD;
8359                         }
8360                       break;
8361
8362                     default:
8363                       continue;
8364                     }
8365
8366                   if (pass == 0)
8367                     {
8368                       if (!expecting_tls_get_addr
8369                           || !sec->has_tls_get_addr_call)
8370                         continue;
8371
8372                       if (rel + 1 < relend
8373                           && branch_reloc_hash_match (ibfd, rel + 1,
8374                                                       htab->tls_get_addr,
8375                                                       htab->tls_get_addr_fd))
8376                         {
8377                           if (expecting_tls_get_addr == 2)
8378                             {
8379                               /* Check for toc tls entries.  */
8380                               unsigned char *toc_tls;
8381                               int retval;
8382
8383                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8384                                                      &locsyms,
8385                                                      rel, ibfd);
8386                               if (retval == 0)
8387                                 goto err_free_rel;
8388                               if (toc_tls != NULL)
8389                                 {
8390                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8391                                     found_tls_get_addr_arg = 1;
8392                                   if (retval > 1)
8393                                     toc_ref[toc_ref_index] = 1;
8394                                 }
8395                             }
8396                           continue;
8397                         }
8398
8399                       if (expecting_tls_get_addr != 1)
8400                         continue;
8401
8402                       /* Uh oh, we didn't find the expected call.  We
8403                          could just mark this symbol to exclude it
8404                          from tls optimization but it's safer to skip
8405                          the entire optimization.  */
8406                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8407                                                 "TLS optimization disabled\n"),
8408                                               ibfd, sec, rel->r_offset);
8409                       ret = TRUE;
8410                       goto err_free_rel;
8411                     }
8412
8413                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8414                     {
8415                       struct plt_entry *ent;
8416                       for (ent = htab->tls_get_addr->elf.plt.plist;
8417                            ent != NULL;
8418                            ent = ent->next)
8419                         if (ent->addend == 0)
8420                           {
8421                             if (ent->plt.refcount > 0)
8422                               {
8423                                 ent->plt.refcount -= 1;
8424                                 expecting_tls_get_addr = 0;
8425                               }
8426                             break;
8427                           }
8428                     }
8429
8430                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8431                     {
8432                       struct plt_entry *ent;
8433                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8434                            ent != NULL;
8435                            ent = ent->next)
8436                         if (ent->addend == 0)
8437                           {
8438                             if (ent->plt.refcount > 0)
8439                               ent->plt.refcount -= 1;
8440                             break;
8441                           }
8442                     }
8443
8444                   if (tls_clear == 0)
8445                     continue;
8446
8447                   if ((tls_set & TLS_EXPLICIT) == 0)
8448                     {
8449                       struct got_entry *ent;
8450
8451                       /* Adjust got entry for this reloc.  */
8452                       if (h != NULL)
8453                         ent = h->got.glist;
8454                       else
8455                         ent = elf_local_got_ents (ibfd)[r_symndx];
8456
8457                       for (; ent != NULL; ent = ent->next)
8458                         if (ent->addend == rel->r_addend
8459                             && ent->owner == ibfd
8460                             && ent->tls_type == tls_type)
8461                           break;
8462                       if (ent == NULL)
8463                         abort ();
8464
8465                       if (tls_set == 0)
8466                         {
8467                           /* We managed to get rid of a got entry.  */
8468                           if (ent->got.refcount > 0)
8469                             ent->got.refcount -= 1;
8470                         }
8471                     }
8472                   else
8473                     {
8474                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8475                          we'll lose one or two dyn relocs.  */
8476                       if (!dec_dynrel_count (rel->r_info, sec, info,
8477                                              NULL, h, sym))
8478                         return FALSE;
8479
8480                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8481                         {
8482                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8483                                                  NULL, h, sym))
8484                             return FALSE;
8485                         }
8486                     }
8487
8488                   *tls_mask |= tls_set;
8489                   *tls_mask &= ~tls_clear;
8490                 }
8491
8492               if (elf_section_data (sec)->relocs != relstart)
8493                 free (relstart);
8494             }
8495
8496         if (locsyms != NULL
8497             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8498           {
8499             if (!info->keep_memory)
8500               free (locsyms);
8501             else
8502               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8503           }
8504       }
8505
8506   if (toc_ref != NULL)
8507     free (toc_ref);
8508   return TRUE;
8509 }
8510
8511 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8512    the values of any global symbols in a toc section that has been
8513    edited.  Globals in toc sections should be a rarity, so this function
8514    sets a flag if any are found in toc sections other than the one just
8515    edited, so that futher hash table traversals can be avoided.  */
8516
8517 struct adjust_toc_info
8518 {
8519   asection *toc;
8520   unsigned long *skip;
8521   bfd_boolean global_toc_syms;
8522 };
8523
8524 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8525
8526 static bfd_boolean
8527 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8528 {
8529   struct ppc_link_hash_entry *eh;
8530   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8531   unsigned long i;
8532
8533   if (h->root.type != bfd_link_hash_defined
8534       && h->root.type != bfd_link_hash_defweak)
8535     return TRUE;
8536
8537   eh = (struct ppc_link_hash_entry *) h;
8538   if (eh->adjust_done)
8539     return TRUE;
8540
8541   if (eh->elf.root.u.def.section == toc_inf->toc)
8542     {
8543       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8544         i = toc_inf->toc->rawsize >> 3;
8545       else
8546         i = eh->elf.root.u.def.value >> 3;
8547
8548       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8549         {
8550           (*_bfd_error_handler)
8551             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8552           do
8553             ++i;
8554           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8555           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8556         }
8557
8558       eh->elf.root.u.def.value -= toc_inf->skip[i];
8559       eh->adjust_done = 1;
8560     }
8561   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8562     toc_inf->global_toc_syms = TRUE;
8563
8564   return TRUE;
8565 }
8566
8567 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8568
8569 static bfd_boolean
8570 ok_lo_toc_insn (unsigned int insn)
8571 {
8572   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8573           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8574           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8575           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8576           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8577           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8578           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8579           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8580           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8581           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8582           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8583           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8584           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8585           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8586           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8587               && (insn & 3) != 1)
8588           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8589               && ((insn & 3) == 0 || (insn & 3) == 3))
8590           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8591 }
8592
8593 /* Examine all relocs referencing .toc sections in order to remove
8594    unused .toc entries.  */
8595
8596 bfd_boolean
8597 ppc64_elf_edit_toc (struct bfd_link_info *info)
8598 {
8599   bfd *ibfd;
8600   struct adjust_toc_info toc_inf;
8601   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8602
8603   htab->do_toc_opt = 1;
8604   toc_inf.global_toc_syms = TRUE;
8605   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8606     {
8607       asection *toc, *sec;
8608       Elf_Internal_Shdr *symtab_hdr;
8609       Elf_Internal_Sym *local_syms;
8610       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8611       unsigned long *skip, *drop;
8612       unsigned char *used;
8613       unsigned char *keep, last, some_unused;
8614
8615       if (!is_ppc64_elf (ibfd))
8616         continue;
8617
8618       toc = bfd_get_section_by_name (ibfd, ".toc");
8619       if (toc == NULL
8620           || toc->size == 0
8621           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8622           || discarded_section (toc))
8623         continue;
8624
8625       toc_relocs = NULL;
8626       local_syms = NULL;
8627       symtab_hdr = &elf_symtab_hdr (ibfd);
8628
8629       /* Look at sections dropped from the final link.  */
8630       skip = NULL;
8631       relstart = NULL;
8632       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8633         {
8634           if (sec->reloc_count == 0
8635               || !discarded_section (sec)
8636               || get_opd_info (sec)
8637               || (sec->flags & SEC_ALLOC) == 0
8638               || (sec->flags & SEC_DEBUGGING) != 0)
8639             continue;
8640
8641           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8642           if (relstart == NULL)
8643             goto error_ret;
8644
8645           /* Run through the relocs to see which toc entries might be
8646              unused.  */
8647           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8648             {
8649               enum elf_ppc64_reloc_type r_type;
8650               unsigned long r_symndx;
8651               asection *sym_sec;
8652               struct elf_link_hash_entry *h;
8653               Elf_Internal_Sym *sym;
8654               bfd_vma val;
8655
8656               r_type = ELF64_R_TYPE (rel->r_info);
8657               switch (r_type)
8658                 {
8659                 default:
8660                   continue;
8661
8662                 case R_PPC64_TOC16:
8663                 case R_PPC64_TOC16_LO:
8664                 case R_PPC64_TOC16_HI:
8665                 case R_PPC64_TOC16_HA:
8666                 case R_PPC64_TOC16_DS:
8667                 case R_PPC64_TOC16_LO_DS:
8668                   break;
8669                 }
8670
8671               r_symndx = ELF64_R_SYM (rel->r_info);
8672               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8673                               r_symndx, ibfd))
8674                 goto error_ret;
8675
8676               if (sym_sec != toc)
8677                 continue;
8678
8679               if (h != NULL)
8680                 val = h->root.u.def.value;
8681               else
8682                 val = sym->st_value;
8683               val += rel->r_addend;
8684
8685               if (val >= toc->size)
8686                 continue;
8687
8688               /* Anything in the toc ought to be aligned to 8 bytes.
8689                  If not, don't mark as unused.  */
8690               if (val & 7)
8691                 continue;
8692
8693               if (skip == NULL)
8694                 {
8695                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8696                   if (skip == NULL)
8697                     goto error_ret;
8698                 }
8699
8700               skip[val >> 3] = ref_from_discarded;
8701             }
8702
8703           if (elf_section_data (sec)->relocs != relstart)
8704             free (relstart);
8705         }
8706
8707       /* For largetoc loads of address constants, we can convert
8708          .  addis rx,2,addr@got@ha
8709          .  ld ry,addr@got@l(rx)
8710          to
8711          .  addis rx,2,addr@toc@ha
8712          .  addi ry,rx,addr@toc@l
8713          when addr is within 2G of the toc pointer.  This then means
8714          that the word storing "addr" in the toc is no longer needed.  */
8715
8716       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8717           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8718           && toc->reloc_count != 0)
8719         {
8720           /* Read toc relocs.  */
8721           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8722                                                   info->keep_memory);
8723           if (toc_relocs == NULL)
8724             goto error_ret;
8725
8726           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8727             {
8728               enum elf_ppc64_reloc_type r_type;
8729               unsigned long r_symndx;
8730               asection *sym_sec;
8731               struct elf_link_hash_entry *h;
8732               Elf_Internal_Sym *sym;
8733               bfd_vma val, addr;
8734
8735               r_type = ELF64_R_TYPE (rel->r_info);
8736               if (r_type != R_PPC64_ADDR64)
8737                 continue;
8738
8739               r_symndx = ELF64_R_SYM (rel->r_info);
8740               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8741                               r_symndx, ibfd))
8742                 goto error_ret;
8743
8744               if (sym_sec == NULL
8745                   || discarded_section (sym_sec))
8746                 continue;
8747
8748               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8749                 continue;
8750
8751               if (h != NULL)
8752                 {
8753                   if (h->type == STT_GNU_IFUNC)
8754                     continue;
8755                   val = h->root.u.def.value;
8756                 }
8757               else
8758                 {
8759                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8760                     continue;
8761                   val = sym->st_value;
8762                 }
8763               val += rel->r_addend;
8764               val += sym_sec->output_section->vma + sym_sec->output_offset;
8765
8766               /* We don't yet know the exact toc pointer value, but we
8767                  know it will be somewhere in the toc section.  Don't
8768                  optimize if the difference from any possible toc
8769                  pointer is outside [ff..f80008000, 7fff7fff].  */
8770               addr = toc->output_section->vma + TOC_BASE_OFF;
8771               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8772                 continue;
8773
8774               addr = toc->output_section->vma + toc->output_section->rawsize;
8775               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8776                 continue;
8777
8778               if (skip == NULL)
8779                 {
8780                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8781                   if (skip == NULL)
8782                     goto error_ret;
8783                 }
8784
8785               skip[rel->r_offset >> 3]
8786                 |= can_optimize | ((rel - toc_relocs) << 2);
8787             }
8788         }
8789
8790       if (skip == NULL)
8791         continue;
8792
8793       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8794       if (used == NULL)
8795         {
8796         error_ret:
8797           if (local_syms != NULL
8798               && symtab_hdr->contents != (unsigned char *) local_syms)
8799             free (local_syms);
8800           if (sec != NULL
8801               && relstart != NULL
8802               && elf_section_data (sec)->relocs != relstart)
8803             free (relstart);
8804           if (toc_relocs != NULL
8805               && elf_section_data (toc)->relocs != toc_relocs)
8806             free (toc_relocs);
8807           if (skip != NULL)
8808             free (skip);
8809           return FALSE;
8810         }
8811
8812       /* Now check all kept sections that might reference the toc.
8813          Check the toc itself last.  */
8814       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8815                   : ibfd->sections);
8816            sec != NULL;
8817            sec = (sec == toc ? NULL
8818                   : sec->next == NULL ? toc
8819                   : sec->next == toc && toc->next ? toc->next
8820                   : sec->next))
8821         {
8822           int repeat;
8823
8824           if (sec->reloc_count == 0
8825               || discarded_section (sec)
8826               || get_opd_info (sec)
8827               || (sec->flags & SEC_ALLOC) == 0
8828               || (sec->flags & SEC_DEBUGGING) != 0)
8829             continue;
8830
8831           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8832                                                 info->keep_memory);
8833           if (relstart == NULL)
8834             {
8835               free (used);
8836               goto error_ret;
8837             }
8838
8839           /* Mark toc entries referenced as used.  */
8840           do
8841             {
8842               repeat = 0;
8843               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8844                 {
8845                   enum elf_ppc64_reloc_type r_type;
8846                   unsigned long r_symndx;
8847                   asection *sym_sec;
8848                   struct elf_link_hash_entry *h;
8849                   Elf_Internal_Sym *sym;
8850                   bfd_vma val;
8851                   enum {no_check, check_lo, check_ha} insn_check;
8852
8853                   r_type = ELF64_R_TYPE (rel->r_info);
8854                   switch (r_type)
8855                     {
8856                     default:
8857                       insn_check = no_check;
8858                       break;
8859
8860                     case R_PPC64_GOT_TLSLD16_HA:
8861                     case R_PPC64_GOT_TLSGD16_HA:
8862                     case R_PPC64_GOT_TPREL16_HA:
8863                     case R_PPC64_GOT_DTPREL16_HA:
8864                     case R_PPC64_GOT16_HA:
8865                     case R_PPC64_TOC16_HA:
8866                       insn_check = check_ha;
8867                       break;
8868
8869                     case R_PPC64_GOT_TLSLD16_LO:
8870                     case R_PPC64_GOT_TLSGD16_LO:
8871                     case R_PPC64_GOT_TPREL16_LO_DS:
8872                     case R_PPC64_GOT_DTPREL16_LO_DS:
8873                     case R_PPC64_GOT16_LO:
8874                     case R_PPC64_GOT16_LO_DS:
8875                     case R_PPC64_TOC16_LO:
8876                     case R_PPC64_TOC16_LO_DS:
8877                       insn_check = check_lo;
8878                       break;
8879                     }
8880
8881                   if (insn_check != no_check)
8882                     {
8883                       bfd_vma off = rel->r_offset & ~3;
8884                       unsigned char buf[4];
8885                       unsigned int insn;
8886
8887                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8888                         {
8889                           free (used);
8890                           goto error_ret;
8891                         }
8892                       insn = bfd_get_32 (ibfd, buf);
8893                       if (insn_check == check_lo
8894                           ? !ok_lo_toc_insn (insn)
8895                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8896                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8897                         {
8898                           char str[12];
8899
8900                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8901                           sprintf (str, "%#08x", insn);
8902                           info->callbacks->einfo
8903                             (_("%P: %H: toc optimization is not supported for"
8904                                " %s instruction.\n"),
8905                              ibfd, sec, rel->r_offset & ~3, str);
8906                         }
8907                     }
8908
8909                   switch (r_type)
8910                     {
8911                     case R_PPC64_TOC16:
8912                     case R_PPC64_TOC16_LO:
8913                     case R_PPC64_TOC16_HI:
8914                     case R_PPC64_TOC16_HA:
8915                     case R_PPC64_TOC16_DS:
8916                     case R_PPC64_TOC16_LO_DS:
8917                       /* In case we're taking addresses of toc entries.  */
8918                     case R_PPC64_ADDR64:
8919                       break;
8920
8921                     default:
8922                       continue;
8923                     }
8924
8925                   r_symndx = ELF64_R_SYM (rel->r_info);
8926                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8927                                   r_symndx, ibfd))
8928                     {
8929                       free (used);
8930                       goto error_ret;
8931                     }
8932
8933                   if (sym_sec != toc)
8934                     continue;
8935
8936                   if (h != NULL)
8937                     val = h->root.u.def.value;
8938                   else
8939                     val = sym->st_value;
8940                   val += rel->r_addend;
8941
8942                   if (val >= toc->size)
8943                     continue;
8944
8945                   if ((skip[val >> 3] & can_optimize) != 0)
8946                     {
8947                       bfd_vma off;
8948                       unsigned char opc;
8949
8950                       switch (r_type)
8951                         {
8952                         case R_PPC64_TOC16_HA:
8953                           break;
8954
8955                         case R_PPC64_TOC16_LO_DS:
8956                           off = rel->r_offset;
8957                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8958                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8959                                                          off, 1))
8960                             {
8961                               free (used);
8962                               goto error_ret;
8963                             }
8964                           if ((opc & (0x3f << 2)) == (58u << 2))
8965                             break;
8966                           /* Fall thru */
8967
8968                         default:
8969                           /* Wrong sort of reloc, or not a ld.  We may
8970                              as well clear ref_from_discarded too.  */
8971                           skip[val >> 3] = 0;
8972                         }
8973                     }
8974
8975                   if (sec != toc)
8976                     used[val >> 3] = 1;
8977                   /* For the toc section, we only mark as used if this
8978                      entry itself isn't unused.  */
8979                   else if ((used[rel->r_offset >> 3]
8980                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8981                            && !used[val >> 3])
8982                     {
8983                       /* Do all the relocs again, to catch reference
8984                          chains.  */
8985                       repeat = 1;
8986                       used[val >> 3] = 1;
8987                     }
8988                 }
8989             }
8990           while (repeat);
8991
8992           if (elf_section_data (sec)->relocs != relstart)
8993             free (relstart);
8994         }
8995
8996       /* Merge the used and skip arrays.  Assume that TOC
8997          doublewords not appearing as either used or unused belong
8998          to to an entry more than one doubleword in size.  */
8999       for (drop = skip, keep = used, last = 0, some_unused = 0;
9000            drop < skip + (toc->size + 7) / 8;
9001            ++drop, ++keep)
9002         {
9003           if (*keep)
9004             {
9005               *drop &= ~ref_from_discarded;
9006               if ((*drop & can_optimize) != 0)
9007                 some_unused = 1;
9008               last = 0;
9009             }
9010           else if ((*drop & ref_from_discarded) != 0)
9011             {
9012               some_unused = 1;
9013               last = ref_from_discarded;
9014             }
9015           else
9016             *drop = last;
9017         }
9018
9019       free (used);
9020
9021       if (some_unused)
9022         {
9023           bfd_byte *contents, *src;
9024           unsigned long off;
9025           Elf_Internal_Sym *sym;
9026           bfd_boolean local_toc_syms = FALSE;
9027
9028           /* Shuffle the toc contents, and at the same time convert the
9029              skip array from booleans into offsets.  */
9030           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9031             goto error_ret;
9032
9033           elf_section_data (toc)->this_hdr.contents = contents;
9034
9035           for (src = contents, off = 0, drop = skip;
9036                src < contents + toc->size;
9037                src += 8, ++drop)
9038             {
9039               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9040                 off += 8;
9041               else if (off != 0)
9042                 {
9043                   *drop = off;
9044                   memcpy (src - off, src, 8);
9045                 }
9046             }
9047           *drop = off;
9048           toc->rawsize = toc->size;
9049           toc->size = src - contents - off;
9050
9051           /* Adjust addends for relocs against the toc section sym,
9052              and optimize any accesses we can.  */
9053           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9054             {
9055               if (sec->reloc_count == 0
9056                   || discarded_section (sec))
9057                 continue;
9058
9059               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9060                                                     info->keep_memory);
9061               if (relstart == NULL)
9062                 goto error_ret;
9063
9064               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9065                 {
9066                   enum elf_ppc64_reloc_type r_type;
9067                   unsigned long r_symndx;
9068                   asection *sym_sec;
9069                   struct elf_link_hash_entry *h;
9070                   bfd_vma val;
9071
9072                   r_type = ELF64_R_TYPE (rel->r_info);
9073                   switch (r_type)
9074                     {
9075                     default:
9076                       continue;
9077
9078                     case R_PPC64_TOC16:
9079                     case R_PPC64_TOC16_LO:
9080                     case R_PPC64_TOC16_HI:
9081                     case R_PPC64_TOC16_HA:
9082                     case R_PPC64_TOC16_DS:
9083                     case R_PPC64_TOC16_LO_DS:
9084                     case R_PPC64_ADDR64:
9085                       break;
9086                     }
9087
9088                   r_symndx = ELF64_R_SYM (rel->r_info);
9089                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9090                                   r_symndx, ibfd))
9091                     goto error_ret;
9092
9093                   if (sym_sec != toc)
9094                     continue;
9095
9096                   if (h != NULL)
9097                     val = h->root.u.def.value;
9098                   else
9099                     {
9100                       val = sym->st_value;
9101                       if (val != 0)
9102                         local_toc_syms = TRUE;
9103                     }
9104
9105                   val += rel->r_addend;
9106
9107                   if (val > toc->rawsize)
9108                     val = toc->rawsize;
9109                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9110                     continue;
9111                   else if ((skip[val >> 3] & can_optimize) != 0)
9112                     {
9113                       Elf_Internal_Rela *tocrel
9114                         = toc_relocs + (skip[val >> 3] >> 2);
9115                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9116
9117                       switch (r_type)
9118                         {
9119                         case R_PPC64_TOC16_HA:
9120                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9121                           break;
9122
9123                         case R_PPC64_TOC16_LO_DS:
9124                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9125                           break;
9126
9127                         default:
9128                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9129                             ppc_howto_init ();
9130                           info->callbacks->einfo
9131                             (_("%P: %H: %s references "
9132                                "optimized away TOC entry\n"),
9133                              ibfd, sec, rel->r_offset,
9134                              ppc64_elf_howto_table[r_type]->name);
9135                           bfd_set_error (bfd_error_bad_value);
9136                           goto error_ret;
9137                         }
9138                       rel->r_addend = tocrel->r_addend;
9139                       elf_section_data (sec)->relocs = relstart;
9140                       continue;
9141                     }
9142
9143                   if (h != NULL || sym->st_value != 0)
9144                     continue;
9145
9146                   rel->r_addend -= skip[val >> 3];
9147                   elf_section_data (sec)->relocs = relstart;
9148                 }
9149
9150               if (elf_section_data (sec)->relocs != relstart)
9151                 free (relstart);
9152             }
9153
9154           /* We shouldn't have local or global symbols defined in the TOC,
9155              but handle them anyway.  */
9156           if (local_syms != NULL)
9157             for (sym = local_syms;
9158                  sym < local_syms + symtab_hdr->sh_info;
9159                  ++sym)
9160               if (sym->st_value != 0
9161                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9162                 {
9163                   unsigned long i;
9164
9165                   if (sym->st_value > toc->rawsize)
9166                     i = toc->rawsize >> 3;
9167                   else
9168                     i = sym->st_value >> 3;
9169
9170                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9171                     {
9172                       if (local_toc_syms)
9173                         (*_bfd_error_handler)
9174                           (_("%s defined on removed toc entry"),
9175                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9176                       do
9177                         ++i;
9178                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9179                       sym->st_value = (bfd_vma) i << 3;
9180                     }
9181
9182                   sym->st_value -= skip[i];
9183                   symtab_hdr->contents = (unsigned char *) local_syms;
9184                 }
9185
9186           /* Adjust any global syms defined in this toc input section.  */
9187           if (toc_inf.global_toc_syms)
9188             {
9189               toc_inf.toc = toc;
9190               toc_inf.skip = skip;
9191               toc_inf.global_toc_syms = FALSE;
9192               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9193                                       &toc_inf);
9194             }
9195
9196           if (toc->reloc_count != 0)
9197             {
9198               Elf_Internal_Shdr *rel_hdr;
9199               Elf_Internal_Rela *wrel;
9200               bfd_size_type sz;
9201
9202               /* Remove unused toc relocs, and adjust those we keep.  */
9203               if (toc_relocs == NULL)
9204                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9205                                                         info->keep_memory);
9206               if (toc_relocs == NULL)
9207                 goto error_ret;
9208
9209               wrel = toc_relocs;
9210               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9211                 if ((skip[rel->r_offset >> 3]
9212                      & (ref_from_discarded | can_optimize)) == 0)
9213                   {
9214                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9215                     wrel->r_info = rel->r_info;
9216                     wrel->r_addend = rel->r_addend;
9217                     ++wrel;
9218                   }
9219                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9220                                             &local_syms, NULL, NULL))
9221                   goto error_ret;
9222
9223               elf_section_data (toc)->relocs = toc_relocs;
9224               toc->reloc_count = wrel - toc_relocs;
9225               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9226               sz = rel_hdr->sh_entsize;
9227               rel_hdr->sh_size = toc->reloc_count * sz;
9228             }
9229         }
9230       else if (toc_relocs != NULL
9231                && elf_section_data (toc)->relocs != toc_relocs)
9232         free (toc_relocs);
9233
9234       if (local_syms != NULL
9235           && symtab_hdr->contents != (unsigned char *) local_syms)
9236         {
9237           if (!info->keep_memory)
9238             free (local_syms);
9239           else
9240             symtab_hdr->contents = (unsigned char *) local_syms;
9241         }
9242       free (skip);
9243     }
9244
9245   return TRUE;
9246 }
9247
9248 /* Return true iff input section I references the TOC using
9249    instructions limited to +/-32k offsets.  */
9250
9251 bfd_boolean
9252 ppc64_elf_has_small_toc_reloc (asection *i)
9253 {
9254   return (is_ppc64_elf (i->owner)
9255           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9256 }
9257
9258 /* Allocate space for one GOT entry.  */
9259
9260 static void
9261 allocate_got (struct elf_link_hash_entry *h,
9262               struct bfd_link_info *info,
9263               struct got_entry *gent)
9264 {
9265   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9266   bfd_boolean dyn;
9267   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9268   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9269                  ? 16 : 8);
9270   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9271                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9272   asection *got = ppc64_elf_tdata (gent->owner)->got;
9273
9274   gent->got.offset = got->size;
9275   got->size += entsize;
9276
9277   dyn = htab->elf.dynamic_sections_created;
9278   if (h->type == STT_GNU_IFUNC)
9279     {
9280       htab->elf.irelplt->size += rentsize;
9281       htab->got_reli_size += rentsize;
9282     }
9283   else if ((info->shared
9284             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9285            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9286                || h->root.type != bfd_link_hash_undefweak))
9287     {
9288       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9289       relgot->size += rentsize;
9290     }
9291 }
9292
9293 /* This function merges got entries in the same toc group.  */
9294
9295 static void
9296 merge_got_entries (struct got_entry **pent)
9297 {
9298   struct got_entry *ent, *ent2;
9299
9300   for (ent = *pent; ent != NULL; ent = ent->next)
9301     if (!ent->is_indirect)
9302       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9303         if (!ent2->is_indirect
9304             && ent2->addend == ent->addend
9305             && ent2->tls_type == ent->tls_type
9306             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9307           {
9308             ent2->is_indirect = TRUE;
9309             ent2->got.ent = ent;
9310           }
9311 }
9312
9313 /* Allocate space in .plt, .got and associated reloc sections for
9314    dynamic relocs.  */
9315
9316 static bfd_boolean
9317 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9318 {
9319   struct bfd_link_info *info;
9320   struct ppc_link_hash_table *htab;
9321   asection *s;
9322   struct ppc_link_hash_entry *eh;
9323   struct elf_dyn_relocs *p;
9324   struct got_entry **pgent, *gent;
9325
9326   if (h->root.type == bfd_link_hash_indirect)
9327     return TRUE;
9328
9329   info = (struct bfd_link_info *) inf;
9330   htab = ppc_hash_table (info);
9331   if (htab == NULL)
9332     return FALSE;
9333
9334   if ((htab->elf.dynamic_sections_created
9335        && h->dynindx != -1
9336        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9337       || h->type == STT_GNU_IFUNC)
9338     {
9339       struct plt_entry *pent;
9340       bfd_boolean doneone = FALSE;
9341       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9342         if (pent->plt.refcount > 0)
9343           {
9344             if (!htab->elf.dynamic_sections_created
9345                 || h->dynindx == -1)
9346               {
9347                 s = htab->elf.iplt;
9348                 pent->plt.offset = s->size;
9349                 s->size += PLT_ENTRY_SIZE (htab);
9350                 s = htab->elf.irelplt;
9351               }
9352             else
9353               {
9354                 /* If this is the first .plt entry, make room for the special
9355                    first entry.  */
9356                 s = htab->elf.splt;
9357                 if (s->size == 0)
9358                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9359
9360                 pent->plt.offset = s->size;
9361
9362                 /* Make room for this entry.  */
9363                 s->size += PLT_ENTRY_SIZE (htab);
9364
9365                 /* Make room for the .glink code.  */
9366                 s = htab->glink;
9367                 if (s->size == 0)
9368                   s->size += GLINK_CALL_STUB_SIZE;
9369                 if (htab->opd_abi)
9370                   {
9371                     /* We need bigger stubs past index 32767.  */
9372                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9373                       s->size += 4;
9374                     s->size += 2*4;
9375                   }
9376                 else
9377                   s->size += 4;
9378
9379                 /* We also need to make an entry in the .rela.plt section.  */
9380                 s = htab->elf.srelplt;
9381               }
9382             s->size += sizeof (Elf64_External_Rela);
9383             doneone = TRUE;
9384           }
9385         else
9386           pent->plt.offset = (bfd_vma) -1;
9387       if (!doneone)
9388         {
9389           h->plt.plist = NULL;
9390           h->needs_plt = 0;
9391         }
9392     }
9393   else
9394     {
9395       h->plt.plist = NULL;
9396       h->needs_plt = 0;
9397     }
9398
9399   eh = (struct ppc_link_hash_entry *) h;
9400   /* Run through the TLS GD got entries first if we're changing them
9401      to TPREL.  */
9402   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9403     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9404       if (gent->got.refcount > 0
9405           && (gent->tls_type & TLS_GD) != 0)
9406         {
9407           /* This was a GD entry that has been converted to TPREL.  If
9408              there happens to be a TPREL entry we can use that one.  */
9409           struct got_entry *ent;
9410           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9411             if (ent->got.refcount > 0
9412                 && (ent->tls_type & TLS_TPREL) != 0
9413                 && ent->addend == gent->addend
9414                 && ent->owner == gent->owner)
9415               {
9416                 gent->got.refcount = 0;
9417                 break;
9418               }
9419
9420           /* If not, then we'll be using our own TPREL entry.  */
9421           if (gent->got.refcount != 0)
9422             gent->tls_type = TLS_TLS | TLS_TPREL;
9423         }
9424
9425   /* Remove any list entry that won't generate a word in the GOT before
9426      we call merge_got_entries.  Otherwise we risk merging to empty
9427      entries.  */
9428   pgent = &h->got.glist;
9429   while ((gent = *pgent) != NULL)
9430     if (gent->got.refcount > 0)
9431       {
9432         if ((gent->tls_type & TLS_LD) != 0
9433             && !h->def_dynamic)
9434           {
9435             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9436             *pgent = gent->next;
9437           }
9438         else
9439           pgent = &gent->next;
9440       }
9441     else
9442       *pgent = gent->next;
9443
9444   if (!htab->do_multi_toc)
9445     merge_got_entries (&h->got.glist);
9446
9447   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9448     if (!gent->is_indirect)
9449       {
9450         /* Make sure this symbol is output as a dynamic symbol.
9451            Undefined weak syms won't yet be marked as dynamic,
9452            nor will all TLS symbols.  */
9453         if (h->dynindx == -1
9454             && !h->forced_local
9455             && h->type != STT_GNU_IFUNC
9456             && htab->elf.dynamic_sections_created)
9457           {
9458             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9459               return FALSE;
9460           }
9461
9462         if (!is_ppc64_elf (gent->owner))
9463           abort ();
9464
9465         allocate_got (h, info, gent);
9466       }
9467
9468   if (eh->dyn_relocs == NULL
9469       || (!htab->elf.dynamic_sections_created
9470           && h->type != STT_GNU_IFUNC))
9471     return TRUE;
9472
9473   /* In the shared -Bsymbolic case, discard space allocated for
9474      dynamic pc-relative relocs against symbols which turn out to be
9475      defined in regular objects.  For the normal shared case, discard
9476      space for relocs that have become local due to symbol visibility
9477      changes.  */
9478
9479   if (info->shared)
9480     {
9481       /* Relocs that use pc_count are those that appear on a call insn,
9482          or certain REL relocs (see must_be_dyn_reloc) that can be
9483          generated via assembly.  We want calls to protected symbols to
9484          resolve directly to the function rather than going via the plt.
9485          If people want function pointer comparisons to work as expected
9486          then they should avoid writing weird assembly.  */
9487       if (SYMBOL_CALLS_LOCAL (info, h))
9488         {
9489           struct elf_dyn_relocs **pp;
9490
9491           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9492             {
9493               p->count -= p->pc_count;
9494               p->pc_count = 0;
9495               if (p->count == 0)
9496                 *pp = p->next;
9497               else
9498                 pp = &p->next;
9499             }
9500         }
9501
9502       /* Also discard relocs on undefined weak syms with non-default
9503          visibility.  */
9504       if (eh->dyn_relocs != NULL
9505           && h->root.type == bfd_link_hash_undefweak)
9506         {
9507           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9508             eh->dyn_relocs = NULL;
9509
9510           /* Make sure this symbol is output as a dynamic symbol.
9511              Undefined weak syms won't yet be marked as dynamic.  */
9512           else if (h->dynindx == -1
9513                    && !h->forced_local)
9514             {
9515               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9516                 return FALSE;
9517             }
9518         }
9519     }
9520   else if (h->type == STT_GNU_IFUNC)
9521     {
9522       if (!h->non_got_ref)
9523         eh->dyn_relocs = NULL;
9524     }
9525   else if (ELIMINATE_COPY_RELOCS)
9526     {
9527       /* For the non-shared case, discard space for relocs against
9528          symbols which turn out to need copy relocs or are not
9529          dynamic.  */
9530
9531       if (!h->non_got_ref
9532           && !h->def_regular)
9533         {
9534           /* Make sure this symbol is output as a dynamic symbol.
9535              Undefined weak syms won't yet be marked as dynamic.  */
9536           if (h->dynindx == -1
9537               && !h->forced_local)
9538             {
9539               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9540                 return FALSE;
9541             }
9542
9543           /* If that succeeded, we know we'll be keeping all the
9544              relocs.  */
9545           if (h->dynindx != -1)
9546             goto keep;
9547         }
9548
9549       eh->dyn_relocs = NULL;
9550
9551     keep: ;
9552     }
9553
9554   /* Finally, allocate space.  */
9555   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9556     {
9557       asection *sreloc = elf_section_data (p->sec)->sreloc;
9558       if (eh->elf.type == STT_GNU_IFUNC)
9559         sreloc = htab->elf.irelplt;
9560       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9561     }
9562
9563   return TRUE;
9564 }
9565
9566 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9567    to set up space for global entry stubs.  These are put in glink,
9568    after the branch table.  */
9569
9570 static bfd_boolean
9571 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9572 {
9573   struct bfd_link_info *info;
9574   struct ppc_link_hash_table *htab;
9575   struct plt_entry *pent;
9576   asection *s;
9577
9578   if (h->root.type == bfd_link_hash_indirect)
9579     return TRUE;
9580
9581   if (!h->pointer_equality_needed)
9582     return TRUE;
9583
9584   if (h->def_regular)
9585     return TRUE;
9586
9587   info = inf;
9588   htab = ppc_hash_table (info);
9589   if (htab == NULL)
9590     return FALSE;
9591
9592   s = htab->glink;
9593   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9594     if (pent->plt.offset != (bfd_vma) -1
9595         && pent->addend == 0)
9596       {
9597         /* For ELFv2, if this symbol is not defined in a regular file
9598            and we are not generating a shared library or pie, then we
9599            need to define the symbol in the executable on a call stub.
9600            This is to avoid text relocations.  */
9601         s->size = (s->size + 15) & -16;
9602         h->root.u.def.section = s;
9603         h->root.u.def.value = s->size;
9604         s->size += 16;
9605         break;
9606       }
9607   return TRUE;
9608 }
9609
9610 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9611    read-only sections.  */
9612
9613 static bfd_boolean
9614 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9615 {
9616   if (h->root.type == bfd_link_hash_indirect)
9617     return TRUE;
9618
9619   if (readonly_dynrelocs (h))
9620     {
9621       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9622
9623       /* Not an error, just cut short the traversal.  */
9624       return FALSE;
9625     }
9626   return TRUE;
9627 }
9628
9629 /* Set the sizes of the dynamic sections.  */
9630
9631 static bfd_boolean
9632 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9633                                  struct bfd_link_info *info)
9634 {
9635   struct ppc_link_hash_table *htab;
9636   bfd *dynobj;
9637   asection *s;
9638   bfd_boolean relocs;
9639   bfd *ibfd;
9640   struct got_entry *first_tlsld;
9641
9642   htab = ppc_hash_table (info);
9643   if (htab == NULL)
9644     return FALSE;
9645
9646   dynobj = htab->elf.dynobj;
9647   if (dynobj == NULL)
9648     abort ();
9649
9650   if (htab->elf.dynamic_sections_created)
9651     {
9652       /* Set the contents of the .interp section to the interpreter.  */
9653       if (info->executable)
9654         {
9655           s = bfd_get_linker_section (dynobj, ".interp");
9656           if (s == NULL)
9657             abort ();
9658           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9659           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9660         }
9661     }
9662
9663   /* Set up .got offsets for local syms, and space for local dynamic
9664      relocs.  */
9665   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9666     {
9667       struct got_entry **lgot_ents;
9668       struct got_entry **end_lgot_ents;
9669       struct plt_entry **local_plt;
9670       struct plt_entry **end_local_plt;
9671       unsigned char *lgot_masks;
9672       bfd_size_type locsymcount;
9673       Elf_Internal_Shdr *symtab_hdr;
9674
9675       if (!is_ppc64_elf (ibfd))
9676         continue;
9677
9678       for (s = ibfd->sections; s != NULL; s = s->next)
9679         {
9680           struct ppc_dyn_relocs *p;
9681
9682           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9683             {
9684               if (!bfd_is_abs_section (p->sec)
9685                   && bfd_is_abs_section (p->sec->output_section))
9686                 {
9687                   /* Input section has been discarded, either because
9688                      it is a copy of a linkonce section or due to
9689                      linker script /DISCARD/, so we'll be discarding
9690                      the relocs too.  */
9691                 }
9692               else if (p->count != 0)
9693                 {
9694                   asection *srel = elf_section_data (p->sec)->sreloc;
9695                   if (p->ifunc)
9696                     srel = htab->elf.irelplt;
9697                   srel->size += p->count * sizeof (Elf64_External_Rela);
9698                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9699                     info->flags |= DF_TEXTREL;
9700                 }
9701             }
9702         }
9703
9704       lgot_ents = elf_local_got_ents (ibfd);
9705       if (!lgot_ents)
9706         continue;
9707
9708       symtab_hdr = &elf_symtab_hdr (ibfd);
9709       locsymcount = symtab_hdr->sh_info;
9710       end_lgot_ents = lgot_ents + locsymcount;
9711       local_plt = (struct plt_entry **) end_lgot_ents;
9712       end_local_plt = local_plt + locsymcount;
9713       lgot_masks = (unsigned char *) end_local_plt;
9714       s = ppc64_elf_tdata (ibfd)->got;
9715       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9716         {
9717           struct got_entry **pent, *ent;
9718
9719           pent = lgot_ents;
9720           while ((ent = *pent) != NULL)
9721             if (ent->got.refcount > 0)
9722               {
9723                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9724                   {
9725                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9726                     *pent = ent->next;
9727                   }
9728                 else
9729                   {
9730                     unsigned int ent_size = 8;
9731                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9732
9733                     ent->got.offset = s->size;
9734                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9735                       {
9736                         ent_size *= 2;
9737                         rel_size *= 2;
9738                       }
9739                     s->size += ent_size;
9740                     if ((*lgot_masks & PLT_IFUNC) != 0)
9741                       {
9742                         htab->elf.irelplt->size += rel_size;
9743                         htab->got_reli_size += rel_size;
9744                       }
9745                     else if (info->shared)
9746                       {
9747                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9748                         srel->size += rel_size;
9749                       }
9750                     pent = &ent->next;
9751                   }
9752               }
9753             else
9754               *pent = ent->next;
9755         }
9756
9757       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9758       for (; local_plt < end_local_plt; ++local_plt)
9759         {
9760           struct plt_entry *ent;
9761
9762           for (ent = *local_plt; ent != NULL; ent = ent->next)
9763             if (ent->plt.refcount > 0)
9764               {
9765                 s = htab->elf.iplt;
9766                 ent->plt.offset = s->size;
9767                 s->size += PLT_ENTRY_SIZE (htab);
9768
9769                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9770               }
9771             else
9772               ent->plt.offset = (bfd_vma) -1;
9773         }
9774     }
9775
9776   /* Allocate global sym .plt and .got entries, and space for global
9777      sym dynamic relocs.  */
9778   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9779   /* Stash the end of glink branch table.  */
9780   if (htab->glink != NULL)
9781     htab->glink->rawsize = htab->glink->size;
9782
9783   if (!htab->opd_abi && !info->shared)
9784     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9785
9786   first_tlsld = NULL;
9787   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9788     {
9789       struct got_entry *ent;
9790
9791       if (!is_ppc64_elf (ibfd))
9792         continue;
9793
9794       ent = ppc64_tlsld_got (ibfd);
9795       if (ent->got.refcount > 0)
9796         {
9797           if (!htab->do_multi_toc && first_tlsld != NULL)
9798             {
9799               ent->is_indirect = TRUE;
9800               ent->got.ent = first_tlsld;
9801             }
9802           else
9803             {
9804               if (first_tlsld == NULL)
9805                 first_tlsld = ent;
9806               s = ppc64_elf_tdata (ibfd)->got;
9807               ent->got.offset = s->size;
9808               ent->owner = ibfd;
9809               s->size += 16;
9810               if (info->shared)
9811                 {
9812                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9813                   srel->size += sizeof (Elf64_External_Rela);
9814                 }
9815             }
9816         }
9817       else
9818         ent->got.offset = (bfd_vma) -1;
9819     }
9820
9821   /* We now have determined the sizes of the various dynamic sections.
9822      Allocate memory for them.  */
9823   relocs = FALSE;
9824   for (s = dynobj->sections; s != NULL; s = s->next)
9825     {
9826       if ((s->flags & SEC_LINKER_CREATED) == 0)
9827         continue;
9828
9829       if (s == htab->brlt || s == htab->relbrlt)
9830         /* These haven't been allocated yet;  don't strip.  */
9831         continue;
9832       else if (s == htab->elf.sgot
9833                || s == htab->elf.splt
9834                || s == htab->elf.iplt
9835                || s == htab->glink
9836                || s == htab->dynbss)
9837         {
9838           /* Strip this section if we don't need it; see the
9839              comment below.  */
9840         }
9841       else if (s == htab->glink_eh_frame)
9842         {
9843           if (!bfd_is_abs_section (s->output_section))
9844             /* Not sized yet.  */
9845             continue;
9846         }
9847       else if (CONST_STRNEQ (s->name, ".rela"))
9848         {
9849           if (s->size != 0)
9850             {
9851               if (s != htab->elf.srelplt)
9852                 relocs = TRUE;
9853
9854               /* We use the reloc_count field as a counter if we need
9855                  to copy relocs into the output file.  */
9856               s->reloc_count = 0;
9857             }
9858         }
9859       else
9860         {
9861           /* It's not one of our sections, so don't allocate space.  */
9862           continue;
9863         }
9864
9865       if (s->size == 0)
9866         {
9867           /* If we don't need this section, strip it from the
9868              output file.  This is mostly to handle .rela.bss and
9869              .rela.plt.  We must create both sections in
9870              create_dynamic_sections, because they must be created
9871              before the linker maps input sections to output
9872              sections.  The linker does that before
9873              adjust_dynamic_symbol is called, and it is that
9874              function which decides whether anything needs to go
9875              into these sections.  */
9876           s->flags |= SEC_EXCLUDE;
9877           continue;
9878         }
9879
9880       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9881         continue;
9882
9883       /* Allocate memory for the section contents.  We use bfd_zalloc
9884          here in case unused entries are not reclaimed before the
9885          section's contents are written out.  This should not happen,
9886          but this way if it does we get a R_PPC64_NONE reloc in .rela
9887          sections instead of garbage.
9888          We also rely on the section contents being zero when writing
9889          the GOT.  */
9890       s->contents = bfd_zalloc (dynobj, s->size);
9891       if (s->contents == NULL)
9892         return FALSE;
9893     }
9894
9895   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9896     {
9897       if (!is_ppc64_elf (ibfd))
9898         continue;
9899
9900       s = ppc64_elf_tdata (ibfd)->got;
9901       if (s != NULL && s != htab->elf.sgot)
9902         {
9903           if (s->size == 0)
9904             s->flags |= SEC_EXCLUDE;
9905           else
9906             {
9907               s->contents = bfd_zalloc (ibfd, s->size);
9908               if (s->contents == NULL)
9909                 return FALSE;
9910             }
9911         }
9912       s = ppc64_elf_tdata (ibfd)->relgot;
9913       if (s != NULL)
9914         {
9915           if (s->size == 0)
9916             s->flags |= SEC_EXCLUDE;
9917           else
9918             {
9919               s->contents = bfd_zalloc (ibfd, s->size);
9920               if (s->contents == NULL)
9921                 return FALSE;
9922               relocs = TRUE;
9923               s->reloc_count = 0;
9924             }
9925         }
9926     }
9927
9928   if (htab->elf.dynamic_sections_created)
9929     {
9930       bfd_boolean tls_opt;
9931
9932       /* Add some entries to the .dynamic section.  We fill in the
9933          values later, in ppc64_elf_finish_dynamic_sections, but we
9934          must add the entries now so that we get the correct size for
9935          the .dynamic section.  The DT_DEBUG entry is filled in by the
9936          dynamic linker and used by the debugger.  */
9937 #define add_dynamic_entry(TAG, VAL) \
9938   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9939
9940       if (info->executable)
9941         {
9942           if (!add_dynamic_entry (DT_DEBUG, 0))
9943             return FALSE;
9944         }
9945
9946       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9947         {
9948           if (!add_dynamic_entry (DT_PLTGOT, 0)
9949               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9950               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9951               || !add_dynamic_entry (DT_JMPREL, 0)
9952               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9953             return FALSE;
9954         }
9955
9956       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9957         {
9958           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9959               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9960             return FALSE;
9961         }
9962
9963       tls_opt = (!htab->params->no_tls_get_addr_opt
9964                  && htab->tls_get_addr_fd != NULL
9965                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9966       if (tls_opt || !htab->opd_abi)
9967         {
9968           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9969             return FALSE;
9970         }
9971
9972       if (relocs)
9973         {
9974           if (!add_dynamic_entry (DT_RELA, 0)
9975               || !add_dynamic_entry (DT_RELASZ, 0)
9976               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9977             return FALSE;
9978
9979           /* If any dynamic relocs apply to a read-only section,
9980              then we need a DT_TEXTREL entry.  */
9981           if ((info->flags & DF_TEXTREL) == 0)
9982             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9983
9984           if ((info->flags & DF_TEXTREL) != 0)
9985             {
9986               if (!add_dynamic_entry (DT_TEXTREL, 0))
9987                 return FALSE;
9988             }
9989         }
9990     }
9991 #undef add_dynamic_entry
9992
9993   return TRUE;
9994 }
9995
9996 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9997
9998 static bfd_boolean
9999 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10000 {
10001   if (h->plt.plist != NULL
10002       && !h->def_regular
10003       && !h->pointer_equality_needed)
10004     return FALSE;
10005
10006   return _bfd_elf_hash_symbol (h);
10007 }
10008
10009 /* Determine the type of stub needed, if any, for a call.  */
10010
10011 static inline enum ppc_stub_type
10012 ppc_type_of_stub (asection *input_sec,
10013                   const Elf_Internal_Rela *rel,
10014                   struct ppc_link_hash_entry **hash,
10015                   struct plt_entry **plt_ent,
10016                   bfd_vma destination,
10017                   unsigned long local_off)
10018 {
10019   struct ppc_link_hash_entry *h = *hash;
10020   bfd_vma location;
10021   bfd_vma branch_offset;
10022   bfd_vma max_branch_offset;
10023   enum elf_ppc64_reloc_type r_type;
10024
10025   if (h != NULL)
10026     {
10027       struct plt_entry *ent;
10028       struct ppc_link_hash_entry *fdh = h;
10029       if (h->oh != NULL
10030           && h->oh->is_func_descriptor)
10031         {
10032           fdh = ppc_follow_link (h->oh);
10033           *hash = fdh;
10034         }
10035
10036       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10037         if (ent->addend == rel->r_addend
10038             && ent->plt.offset != (bfd_vma) -1)
10039           {
10040             *plt_ent = ent;
10041             return ppc_stub_plt_call;
10042           }
10043
10044       /* Here, we know we don't have a plt entry.  If we don't have a
10045          either a defined function descriptor or a defined entry symbol
10046          in a regular object file, then it is pointless trying to make
10047          any other type of stub.  */
10048       if (!is_static_defined (&fdh->elf)
10049           && !is_static_defined (&h->elf))
10050         return ppc_stub_none;
10051     }
10052   else if (elf_local_got_ents (input_sec->owner) != NULL)
10053     {
10054       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10055       struct plt_entry **local_plt = (struct plt_entry **)
10056         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10057       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10058
10059       if (local_plt[r_symndx] != NULL)
10060         {
10061           struct plt_entry *ent;
10062
10063           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10064             if (ent->addend == rel->r_addend
10065                 && ent->plt.offset != (bfd_vma) -1)
10066               {
10067                 *plt_ent = ent;
10068                 return ppc_stub_plt_call;
10069               }
10070         }
10071     }
10072
10073   /* Determine where the call point is.  */
10074   location = (input_sec->output_offset
10075               + input_sec->output_section->vma
10076               + rel->r_offset);
10077
10078   branch_offset = destination - location;
10079   r_type = ELF64_R_TYPE (rel->r_info);
10080
10081   /* Determine if a long branch stub is needed.  */
10082   max_branch_offset = 1 << 25;
10083   if (r_type != R_PPC64_REL24)
10084     max_branch_offset = 1 << 15;
10085
10086   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10087     /* We need a stub.  Figure out whether a long_branch or plt_branch
10088        is needed later.  */
10089     return ppc_stub_long_branch;
10090
10091   return ppc_stub_none;
10092 }
10093
10094 /* With power7 weakly ordered memory model, it is possible for ld.so
10095    to update a plt entry in one thread and have another thread see a
10096    stale zero toc entry.  To avoid this we need some sort of acquire
10097    barrier in the call stub.  One solution is to make the load of the
10098    toc word seem to appear to depend on the load of the function entry
10099    word.  Another solution is to test for r2 being zero, and branch to
10100    the appropriate glink entry if so.
10101
10102    .    fake dep barrier        compare
10103    .    ld 12,xxx(2)            ld 12,xxx(2)
10104    .    mtctr 12                mtctr 12
10105    .    xor 11,12,12            ld 2,xxx+8(2)
10106    .    add 2,2,11              cmpldi 2,0
10107    .    ld 2,xxx+8(2)           bnectr+
10108    .    bctr                    b <glink_entry>
10109
10110    The solution involving the compare turns out to be faster, so
10111    that's what we use unless the branch won't reach.  */
10112
10113 #define ALWAYS_USE_FAKE_DEP 0
10114 #define ALWAYS_EMIT_R2SAVE 0
10115
10116 #define PPC_LO(v) ((v) & 0xffff)
10117 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10118 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10119
10120 static inline unsigned int
10121 plt_stub_size (struct ppc_link_hash_table *htab,
10122                struct ppc_stub_hash_entry *stub_entry,
10123                bfd_vma off)
10124 {
10125   unsigned size = 12;
10126
10127   if (ALWAYS_EMIT_R2SAVE
10128       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10129     size += 4;
10130   if (PPC_HA (off) != 0)
10131     size += 4;
10132   if (htab->opd_abi)
10133     {
10134       size += 4;
10135       if (htab->params->plt_static_chain)
10136         size += 4;
10137       if (htab->params->plt_thread_safe)
10138         size += 8;
10139       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10140         size += 4;
10141     }
10142   if (stub_entry->h != NULL
10143       && (stub_entry->h == htab->tls_get_addr_fd
10144           || stub_entry->h == htab->tls_get_addr)
10145       && !htab->params->no_tls_get_addr_opt)
10146     size += 13 * 4;
10147   return size;
10148 }
10149
10150 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10151    then return the padding needed to do so.  */
10152 static inline unsigned int
10153 plt_stub_pad (struct ppc_link_hash_table *htab,
10154               struct ppc_stub_hash_entry *stub_entry,
10155               bfd_vma plt_off)
10156 {
10157   int stub_align = 1 << htab->params->plt_stub_align;
10158   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10159   bfd_vma stub_off = stub_entry->stub_sec->size;
10160
10161   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10162       > (stub_size & -stub_align))
10163     return stub_align - (stub_off & (stub_align - 1));
10164   return 0;
10165 }
10166
10167 /* Build a .plt call stub.  */
10168
10169 static inline bfd_byte *
10170 build_plt_stub (struct ppc_link_hash_table *htab,
10171                 struct ppc_stub_hash_entry *stub_entry,
10172                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10173 {
10174   bfd *obfd = htab->params->stub_bfd;
10175   bfd_boolean plt_load_toc = htab->opd_abi;
10176   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10177   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10178   bfd_boolean use_fake_dep = plt_thread_safe;
10179   bfd_vma cmp_branch_off = 0;
10180
10181   if (!ALWAYS_USE_FAKE_DEP
10182       && plt_load_toc
10183       && plt_thread_safe
10184       && !(stub_entry->h != NULL
10185            && (stub_entry->h == htab->tls_get_addr_fd
10186                || stub_entry->h == htab->tls_get_addr)
10187            && !htab->params->no_tls_get_addr_opt))
10188     {
10189       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10190       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10191                           / PLT_ENTRY_SIZE (htab));
10192       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10193       bfd_vma to, from;
10194
10195       if (pltindex > 32768)
10196         glinkoff += (pltindex - 32768) * 4;
10197       to = (glinkoff
10198             + htab->glink->output_offset
10199             + htab->glink->output_section->vma);
10200       from = (p - stub_entry->stub_sec->contents
10201               + 4 * (ALWAYS_EMIT_R2SAVE
10202                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10203               + 4 * (PPC_HA (offset) != 0)
10204               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10205                      != PPC_HA (offset))
10206               + 4 * (plt_static_chain != 0)
10207               + 20
10208               + stub_entry->stub_sec->output_offset
10209               + stub_entry->stub_sec->output_section->vma);
10210       cmp_branch_off = to - from;
10211       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10212     }
10213
10214   if (PPC_HA (offset) != 0)
10215     {
10216       if (r != NULL)
10217         {
10218           if (ALWAYS_EMIT_R2SAVE
10219               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10220             r[0].r_offset += 4;
10221           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10222           r[1].r_offset = r[0].r_offset + 4;
10223           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10224           r[1].r_addend = r[0].r_addend;
10225           if (plt_load_toc)
10226             {
10227               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10228                 {
10229                   r[2].r_offset = r[1].r_offset + 4;
10230                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10231                   r[2].r_addend = r[0].r_addend;
10232                 }
10233               else
10234                 {
10235                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10236                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10237                   r[2].r_addend = r[0].r_addend + 8;
10238                   if (plt_static_chain)
10239                     {
10240                       r[3].r_offset = r[2].r_offset + 4;
10241                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10242                       r[3].r_addend = r[0].r_addend + 16;
10243                     }
10244                 }
10245             }
10246         }
10247       if (ALWAYS_EMIT_R2SAVE
10248           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10249         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10250       if (plt_load_toc)
10251         {
10252           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10253           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10254         }
10255       else
10256         {
10257           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10258           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10259         }
10260       if (plt_load_toc
10261           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10262         {
10263           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10264           offset = 0;
10265         }
10266       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10267       if (plt_load_toc)
10268         {
10269           if (use_fake_dep)
10270             {
10271               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10272               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10273             }
10274           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10275           if (plt_static_chain)
10276             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10277         }
10278     }
10279   else
10280     {
10281       if (r != NULL)
10282         {
10283           if (ALWAYS_EMIT_R2SAVE
10284               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10285             r[0].r_offset += 4;
10286           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10287           if (plt_load_toc)
10288             {
10289               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10290                 {
10291                   r[1].r_offset = r[0].r_offset + 4;
10292                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10293                   r[1].r_addend = r[0].r_addend;
10294                 }
10295               else
10296                 {
10297                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10298                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10299                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10300                   if (plt_static_chain)
10301                     {
10302                       r[2].r_offset = r[1].r_offset + 4;
10303                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10304                       r[2].r_addend = r[0].r_addend + 8;
10305                     }
10306                 }
10307             }
10308         }
10309       if (ALWAYS_EMIT_R2SAVE
10310           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10311         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10312       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10313       if (plt_load_toc
10314           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10315         {
10316           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10317           offset = 0;
10318         }
10319       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10320       if (plt_load_toc)
10321         {
10322           if (use_fake_dep)
10323             {
10324               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10325               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10326             }
10327           if (plt_static_chain)
10328             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10329           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10330         }
10331     }
10332   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10333     {
10334       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10335       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10336       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10337     }
10338   else
10339     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10340   return p;
10341 }
10342
10343 /* Build a special .plt call stub for __tls_get_addr.  */
10344
10345 #define LD_R11_0R3      0xe9630000
10346 #define LD_R12_0R3      0xe9830000
10347 #define MR_R0_R3        0x7c601b78
10348 #define CMPDI_R11_0     0x2c2b0000
10349 #define ADD_R3_R12_R13  0x7c6c6a14
10350 #define BEQLR           0x4d820020
10351 #define MR_R3_R0        0x7c030378
10352 #define STD_R11_0R1     0xf9610000
10353 #define BCTRL           0x4e800421
10354 #define LD_R11_0R1      0xe9610000
10355 #define MTLR_R11        0x7d6803a6
10356
10357 static inline bfd_byte *
10358 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10359                          struct ppc_stub_hash_entry *stub_entry,
10360                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10361 {
10362   bfd *obfd = htab->params->stub_bfd;
10363
10364   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10365   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10366   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10367   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10368   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10369   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10370   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10371   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10372   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10373
10374   if (r != NULL)
10375     r[0].r_offset += 9 * 4;
10376   p = build_plt_stub (htab, stub_entry, p, offset, r);
10377   bfd_put_32 (obfd, BCTRL, p - 4);
10378
10379   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10380   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10381   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10382   bfd_put_32 (obfd, BLR, p),                    p += 4;
10383
10384   return p;
10385 }
10386
10387 static Elf_Internal_Rela *
10388 get_relocs (asection *sec, int count)
10389 {
10390   Elf_Internal_Rela *relocs;
10391   struct bfd_elf_section_data *elfsec_data;
10392
10393   elfsec_data = elf_section_data (sec);
10394   relocs = elfsec_data->relocs;
10395   if (relocs == NULL)
10396     {
10397       bfd_size_type relsize;
10398       relsize = sec->reloc_count * sizeof (*relocs);
10399       relocs = bfd_alloc (sec->owner, relsize);
10400       if (relocs == NULL)
10401         return NULL;
10402       elfsec_data->relocs = relocs;
10403       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10404                                           sizeof (Elf_Internal_Shdr));
10405       if (elfsec_data->rela.hdr == NULL)
10406         return NULL;
10407       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10408                                         * sizeof (Elf64_External_Rela));
10409       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10410       sec->reloc_count = 0;
10411     }
10412   relocs += sec->reloc_count;
10413   sec->reloc_count += count;
10414   return relocs;
10415 }
10416
10417 static bfd_vma
10418 get_r2off (struct bfd_link_info *info,
10419            struct ppc_stub_hash_entry *stub_entry)
10420 {
10421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10422   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10423
10424   if (r2off == 0)
10425     {
10426       /* Support linking -R objects.  Get the toc pointer from the
10427          opd entry.  */
10428       char buf[8];
10429       if (!htab->opd_abi)
10430         return r2off;
10431       asection *opd = stub_entry->h->elf.root.u.def.section;
10432       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10433
10434       if (strcmp (opd->name, ".opd") != 0
10435           || opd->reloc_count != 0)
10436         {
10437           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10438                                   stub_entry->h->elf.root.root.string);
10439           bfd_set_error (bfd_error_bad_value);
10440           return 0;
10441         }
10442       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10443         return 0;
10444       r2off = bfd_get_64 (opd->owner, buf);
10445       r2off -= elf_gp (info->output_bfd);
10446     }
10447   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10448   return r2off;
10449 }
10450
10451 static bfd_boolean
10452 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10453 {
10454   struct ppc_stub_hash_entry *stub_entry;
10455   struct ppc_branch_hash_entry *br_entry;
10456   struct bfd_link_info *info;
10457   struct ppc_link_hash_table *htab;
10458   bfd_byte *loc;
10459   bfd_byte *p;
10460   bfd_vma dest, off;
10461   int size;
10462   Elf_Internal_Rela *r;
10463   asection *plt;
10464
10465   /* Massage our args to the form they really have.  */
10466   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10467   info = in_arg;
10468
10469   htab = ppc_hash_table (info);
10470   if (htab == NULL)
10471     return FALSE;
10472
10473   /* Make a note of the offset within the stubs for this entry.  */
10474   stub_entry->stub_offset = stub_entry->stub_sec->size;
10475   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10476
10477   htab->stub_count[stub_entry->stub_type - 1] += 1;
10478   switch (stub_entry->stub_type)
10479     {
10480     case ppc_stub_long_branch:
10481     case ppc_stub_long_branch_r2off:
10482       /* Branches are relative.  This is where we are going to.  */
10483       dest = (stub_entry->target_value
10484               + stub_entry->target_section->output_offset
10485               + stub_entry->target_section->output_section->vma);
10486       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10487       off = dest;
10488
10489       /* And this is where we are coming from.  */
10490       off -= (stub_entry->stub_offset
10491               + stub_entry->stub_sec->output_offset
10492               + stub_entry->stub_sec->output_section->vma);
10493
10494       size = 4;
10495       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10496         {
10497           bfd_vma r2off = get_r2off (info, stub_entry);
10498
10499           if (r2off == 0)
10500             {
10501               htab->stub_error = TRUE;
10502               return FALSE;
10503             }
10504           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10505           loc += 4;
10506           size = 12;
10507           if (PPC_HA (r2off) != 0)
10508             {
10509               size = 16;
10510               bfd_put_32 (htab->params->stub_bfd,
10511                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10512               loc += 4;
10513             }
10514           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10515           loc += 4;
10516           off -= size - 4;
10517         }
10518       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10519
10520       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10521         {
10522           info->callbacks->einfo
10523             (_("%P: long branch stub `%s' offset overflow\n"),
10524              stub_entry->root.string);
10525           htab->stub_error = TRUE;
10526           return FALSE;
10527         }
10528
10529       if (info->emitrelocations)
10530         {
10531           r = get_relocs (stub_entry->stub_sec, 1);
10532           if (r == NULL)
10533             return FALSE;
10534           r->r_offset = loc - stub_entry->stub_sec->contents;
10535           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10536           r->r_addend = dest;
10537           if (stub_entry->h != NULL)
10538             {
10539               struct elf_link_hash_entry **hashes;
10540               unsigned long symndx;
10541               struct ppc_link_hash_entry *h;
10542
10543               hashes = elf_sym_hashes (htab->params->stub_bfd);
10544               if (hashes == NULL)
10545                 {
10546                   bfd_size_type hsize;
10547
10548                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10549                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10550                   if (hashes == NULL)
10551                     return FALSE;
10552                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10553                   htab->stub_globals = 1;
10554                 }
10555               symndx = htab->stub_globals++;
10556               h = stub_entry->h;
10557               hashes[symndx] = &h->elf;
10558               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10559               if (h->oh != NULL && h->oh->is_func)
10560                 h = ppc_follow_link (h->oh);
10561               if (h->elf.root.u.def.section != stub_entry->target_section)
10562                 /* H is an opd symbol.  The addend must be zero.  */
10563                 r->r_addend = 0;
10564               else
10565                 {
10566                   off = (h->elf.root.u.def.value
10567                          + h->elf.root.u.def.section->output_offset
10568                          + h->elf.root.u.def.section->output_section->vma);
10569                   r->r_addend -= off;
10570                 }
10571             }
10572         }
10573       break;
10574
10575     case ppc_stub_plt_branch:
10576     case ppc_stub_plt_branch_r2off:
10577       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10578                                          stub_entry->root.string + 9,
10579                                          FALSE, FALSE);
10580       if (br_entry == NULL)
10581         {
10582           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10583                                   stub_entry->root.string);
10584           htab->stub_error = TRUE;
10585           return FALSE;
10586         }
10587
10588       dest = (stub_entry->target_value
10589               + stub_entry->target_section->output_offset
10590               + stub_entry->target_section->output_section->vma);
10591       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10592         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10593
10594       bfd_put_64 (htab->brlt->owner, dest,
10595                   htab->brlt->contents + br_entry->offset);
10596
10597       if (br_entry->iter == htab->stub_iteration)
10598         {
10599           br_entry->iter = 0;
10600
10601           if (htab->relbrlt != NULL)
10602             {
10603               /* Create a reloc for the branch lookup table entry.  */
10604               Elf_Internal_Rela rela;
10605               bfd_byte *rl;
10606
10607               rela.r_offset = (br_entry->offset
10608                                + htab->brlt->output_offset
10609                                + htab->brlt->output_section->vma);
10610               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10611               rela.r_addend = dest;
10612
10613               rl = htab->relbrlt->contents;
10614               rl += (htab->relbrlt->reloc_count++
10615                      * sizeof (Elf64_External_Rela));
10616               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10617             }
10618           else if (info->emitrelocations)
10619             {
10620               r = get_relocs (htab->brlt, 1);
10621               if (r == NULL)
10622                 return FALSE;
10623               /* brlt, being SEC_LINKER_CREATED does not go through the
10624                  normal reloc processing.  Symbols and offsets are not
10625                  translated from input file to output file form, so
10626                  set up the offset per the output file.  */
10627               r->r_offset = (br_entry->offset
10628                              + htab->brlt->output_offset
10629                              + htab->brlt->output_section->vma);
10630               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10631               r->r_addend = dest;
10632             }
10633         }
10634
10635       dest = (br_entry->offset
10636               + htab->brlt->output_offset
10637               + htab->brlt->output_section->vma);
10638
10639       off = (dest
10640              - elf_gp (htab->brlt->output_section->owner)
10641              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10642
10643       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10644         {
10645           info->callbacks->einfo
10646             (_("%P: linkage table error against `%T'\n"),
10647              stub_entry->root.string);
10648           bfd_set_error (bfd_error_bad_value);
10649           htab->stub_error = TRUE;
10650           return FALSE;
10651         }
10652
10653       if (info->emitrelocations)
10654         {
10655           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10656           if (r == NULL)
10657             return FALSE;
10658           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10659           if (bfd_big_endian (info->output_bfd))
10660             r[0].r_offset += 2;
10661           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10662             r[0].r_offset += 4;
10663           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10664           r[0].r_addend = dest;
10665           if (PPC_HA (off) != 0)
10666             {
10667               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10668               r[1].r_offset = r[0].r_offset + 4;
10669               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10670               r[1].r_addend = r[0].r_addend;
10671             }
10672         }
10673
10674       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10675         {
10676           if (PPC_HA (off) != 0)
10677             {
10678               size = 16;
10679               bfd_put_32 (htab->params->stub_bfd,
10680                           ADDIS_R12_R2 | PPC_HA (off), loc);
10681               loc += 4;
10682               bfd_put_32 (htab->params->stub_bfd,
10683                           LD_R12_0R12 | PPC_LO (off), loc);
10684             }
10685           else
10686             {
10687               size = 12;
10688               bfd_put_32 (htab->params->stub_bfd,
10689                           LD_R12_0R2 | PPC_LO (off), loc);
10690             }
10691         }
10692       else
10693         {
10694           bfd_vma r2off = get_r2off (info, stub_entry);
10695
10696           if (r2off == 0 && htab->opd_abi)
10697             {
10698               htab->stub_error = TRUE;
10699               return FALSE;
10700             }
10701
10702           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10703           loc += 4;
10704           size = 16;
10705           if (PPC_HA (off) != 0)
10706             {
10707               size += 4;
10708               bfd_put_32 (htab->params->stub_bfd,
10709                           ADDIS_R12_R2 | PPC_HA (off), loc);
10710               loc += 4;
10711               bfd_put_32 (htab->params->stub_bfd,
10712                           LD_R12_0R12 | PPC_LO (off), loc);
10713             }
10714           else
10715             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10716
10717           if (PPC_HA (r2off) != 0)
10718             {
10719               size += 4;
10720               loc += 4;
10721               bfd_put_32 (htab->params->stub_bfd,
10722                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10723             }
10724           if (PPC_LO (r2off) != 0)
10725             {
10726               size += 4;
10727               loc += 4;
10728               bfd_put_32 (htab->params->stub_bfd,
10729                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10730             }
10731         }
10732       loc += 4;
10733       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10734       loc += 4;
10735       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10736       break;
10737
10738     case ppc_stub_plt_call:
10739     case ppc_stub_plt_call_r2save:
10740       if (stub_entry->h != NULL
10741           && stub_entry->h->is_func_descriptor
10742           && stub_entry->h->oh != NULL)
10743         {
10744           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10745
10746           /* If the old-ABI "dot-symbol" is undefined make it weak so
10747              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10748              FIXME: We used to define the symbol on one of the call
10749              stubs instead, which is why we test symbol section id
10750              against htab->top_id in various places.  Likely all
10751              these checks could now disappear.  */
10752           if (fh->elf.root.type == bfd_link_hash_undefined)
10753             fh->elf.root.type = bfd_link_hash_undefweak;
10754           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10755           fh->was_undefined = 0;
10756         }
10757
10758       /* Now build the stub.  */
10759       dest = stub_entry->plt_ent->plt.offset & ~1;
10760       if (dest >= (bfd_vma) -2)
10761         abort ();
10762
10763       plt = htab->elf.splt;
10764       if (!htab->elf.dynamic_sections_created
10765           || stub_entry->h == NULL
10766           || stub_entry->h->elf.dynindx == -1)
10767         plt = htab->elf.iplt;
10768
10769       dest += plt->output_offset + plt->output_section->vma;
10770
10771       if (stub_entry->h == NULL
10772           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10773         {
10774           Elf_Internal_Rela rela;
10775           bfd_byte *rl;
10776
10777           rela.r_offset = dest;
10778           if (htab->opd_abi)
10779             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10780           else
10781             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10782           rela.r_addend = (stub_entry->target_value
10783                            + stub_entry->target_section->output_offset
10784                            + stub_entry->target_section->output_section->vma);
10785
10786           rl = (htab->elf.irelplt->contents
10787                 + (htab->elf.irelplt->reloc_count++
10788                    * sizeof (Elf64_External_Rela)));
10789           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10790           stub_entry->plt_ent->plt.offset |= 1;
10791         }
10792
10793       off = (dest
10794              - elf_gp (plt->output_section->owner)
10795              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10796
10797       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10798         {
10799           info->callbacks->einfo
10800             (_("%P: linkage table error against `%T'\n"),
10801              stub_entry->h != NULL
10802              ? stub_entry->h->elf.root.root.string
10803              : "<local sym>");
10804           bfd_set_error (bfd_error_bad_value);
10805           htab->stub_error = TRUE;
10806           return FALSE;
10807         }
10808
10809       if (htab->params->plt_stub_align != 0)
10810         {
10811           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10812
10813           stub_entry->stub_sec->size += pad;
10814           stub_entry->stub_offset = stub_entry->stub_sec->size;
10815           loc += pad;
10816         }
10817
10818       r = NULL;
10819       if (info->emitrelocations)
10820         {
10821           r = get_relocs (stub_entry->stub_sec,
10822                           ((PPC_HA (off) != 0)
10823                            + (htab->opd_abi
10824                               ? 2 + (htab->params->plt_static_chain
10825                                      && PPC_HA (off + 16) == PPC_HA (off))
10826                               : 1)));
10827           if (r == NULL)
10828             return FALSE;
10829           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10830           if (bfd_big_endian (info->output_bfd))
10831             r[0].r_offset += 2;
10832           r[0].r_addend = dest;
10833         }
10834       if (stub_entry->h != NULL
10835           && (stub_entry->h == htab->tls_get_addr_fd
10836               || stub_entry->h == htab->tls_get_addr)
10837           && !htab->params->no_tls_get_addr_opt)
10838         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10839       else
10840         p = build_plt_stub (htab, stub_entry, loc, off, r);
10841       size = p - loc;
10842       break;
10843
10844     default:
10845       BFD_FAIL ();
10846       return FALSE;
10847     }
10848
10849   stub_entry->stub_sec->size += size;
10850
10851   if (htab->params->emit_stub_syms)
10852     {
10853       struct elf_link_hash_entry *h;
10854       size_t len1, len2;
10855       char *name;
10856       const char *const stub_str[] = { "long_branch",
10857                                        "long_branch_r2off",
10858                                        "plt_branch",
10859                                        "plt_branch_r2off",
10860                                        "plt_call",
10861                                        "plt_call" };
10862
10863       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10864       len2 = strlen (stub_entry->root.string);
10865       name = bfd_malloc (len1 + len2 + 2);
10866       if (name == NULL)
10867         return FALSE;
10868       memcpy (name, stub_entry->root.string, 9);
10869       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10870       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10871       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10872       if (h == NULL)
10873         return FALSE;
10874       if (h->root.type == bfd_link_hash_new)
10875         {
10876           h->root.type = bfd_link_hash_defined;
10877           h->root.u.def.section = stub_entry->stub_sec;
10878           h->root.u.def.value = stub_entry->stub_offset;
10879           h->ref_regular = 1;
10880           h->def_regular = 1;
10881           h->ref_regular_nonweak = 1;
10882           h->forced_local = 1;
10883           h->non_elf = 0;
10884         }
10885     }
10886
10887   return TRUE;
10888 }
10889
10890 /* As above, but don't actually build the stub.  Just bump offset so
10891    we know stub section sizes, and select plt_branch stubs where
10892    long_branch stubs won't do.  */
10893
10894 static bfd_boolean
10895 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10896 {
10897   struct ppc_stub_hash_entry *stub_entry;
10898   struct bfd_link_info *info;
10899   struct ppc_link_hash_table *htab;
10900   bfd_vma off;
10901   int size;
10902
10903   /* Massage our args to the form they really have.  */
10904   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10905   info = in_arg;
10906
10907   htab = ppc_hash_table (info);
10908   if (htab == NULL)
10909     return FALSE;
10910
10911   if (stub_entry->stub_type == ppc_stub_plt_call
10912       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10913     {
10914       asection *plt;
10915       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10916       if (off >= (bfd_vma) -2)
10917         abort ();
10918       plt = htab->elf.splt;
10919       if (!htab->elf.dynamic_sections_created
10920           || stub_entry->h == NULL
10921           || stub_entry->h->elf.dynindx == -1)
10922         plt = htab->elf.iplt;
10923       off += (plt->output_offset
10924               + plt->output_section->vma
10925               - elf_gp (plt->output_section->owner)
10926               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10927
10928       size = plt_stub_size (htab, stub_entry, off);
10929       if (htab->params->plt_stub_align)
10930         size += plt_stub_pad (htab, stub_entry, off);
10931       if (info->emitrelocations)
10932         {
10933           stub_entry->stub_sec->reloc_count
10934             += ((PPC_HA (off) != 0)
10935                 + (htab->opd_abi
10936                    ? 2 + (htab->params->plt_static_chain
10937                           && PPC_HA (off + 16) == PPC_HA (off))
10938                    : 1));
10939           stub_entry->stub_sec->flags |= SEC_RELOC;
10940         }
10941     }
10942   else
10943     {
10944       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10945          variants.  */
10946       bfd_vma r2off = 0;
10947       bfd_vma local_off = 0;
10948
10949       off = (stub_entry->target_value
10950              + stub_entry->target_section->output_offset
10951              + stub_entry->target_section->output_section->vma);
10952       off -= (stub_entry->stub_sec->size
10953               + stub_entry->stub_sec->output_offset
10954               + stub_entry->stub_sec->output_section->vma);
10955
10956       /* Reset the stub type from the plt variant in case we now
10957          can reach with a shorter stub.  */
10958       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10959         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10960
10961       size = 4;
10962       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10963         {
10964           r2off = get_r2off (info, stub_entry);
10965           if (r2off == 0 && htab->opd_abi)
10966             {
10967               htab->stub_error = TRUE;
10968               return FALSE;
10969             }
10970           size = 12;
10971           if (PPC_HA (r2off) != 0)
10972             size = 16;
10973           off -= size - 4;
10974         }
10975
10976       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10977
10978       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10979          Do the same for -R objects without function descriptors.  */
10980       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10981           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10982               && r2off == 0))
10983         {
10984           struct ppc_branch_hash_entry *br_entry;
10985
10986           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10987                                              stub_entry->root.string + 9,
10988                                              TRUE, FALSE);
10989           if (br_entry == NULL)
10990             {
10991               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10992                                       stub_entry->root.string);
10993               htab->stub_error = TRUE;
10994               return FALSE;
10995             }
10996
10997           if (br_entry->iter != htab->stub_iteration)
10998             {
10999               br_entry->iter = htab->stub_iteration;
11000               br_entry->offset = htab->brlt->size;
11001               htab->brlt->size += 8;
11002
11003               if (htab->relbrlt != NULL)
11004                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11005               else if (info->emitrelocations)
11006                 {
11007                   htab->brlt->reloc_count += 1;
11008                   htab->brlt->flags |= SEC_RELOC;
11009                 }
11010             }
11011
11012           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11013           off = (br_entry->offset
11014                  + htab->brlt->output_offset
11015                  + htab->brlt->output_section->vma
11016                  - elf_gp (htab->brlt->output_section->owner)
11017                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11018
11019           if (info->emitrelocations)
11020             {
11021               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11022               stub_entry->stub_sec->flags |= SEC_RELOC;
11023             }
11024
11025           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11026             {
11027               size = 12;
11028               if (PPC_HA (off) != 0)
11029                 size = 16;
11030             }
11031           else
11032             {
11033               size = 16;
11034               if (PPC_HA (off) != 0)
11035                 size += 4;
11036
11037               if (PPC_HA (r2off) != 0)
11038                 size += 4;
11039               if (PPC_LO (r2off) != 0)
11040                 size += 4;
11041             }
11042         }
11043       else if (info->emitrelocations)
11044         {
11045           stub_entry->stub_sec->reloc_count += 1;
11046           stub_entry->stub_sec->flags |= SEC_RELOC;
11047         }
11048     }
11049
11050   stub_entry->stub_sec->size += size;
11051   return TRUE;
11052 }
11053
11054 /* Set up various things so that we can make a list of input sections
11055    for each output section included in the link.  Returns -1 on error,
11056    0 when no stubs will be needed, and 1 on success.  */
11057
11058 int
11059 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11060 {
11061   bfd *input_bfd;
11062   int top_id, top_index, id;
11063   asection *section;
11064   asection **input_list;
11065   bfd_size_type amt;
11066   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11067
11068   if (htab == NULL)
11069     return -1;
11070
11071   /* Find the top input section id.  */
11072   for (input_bfd = info->input_bfds, top_id = 3;
11073        input_bfd != NULL;
11074        input_bfd = input_bfd->link_next)
11075     {
11076       for (section = input_bfd->sections;
11077            section != NULL;
11078            section = section->next)
11079         {
11080           if (top_id < section->id)
11081             top_id = section->id;
11082         }
11083     }
11084
11085   htab->top_id = top_id;
11086   amt = sizeof (struct map_stub) * (top_id + 1);
11087   htab->stub_group = bfd_zmalloc (amt);
11088   if (htab->stub_group == NULL)
11089     return -1;
11090
11091   /* Set toc_off for com, und, abs and ind sections.  */
11092   for (id = 0; id < 3; id++)
11093     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11094
11095   /* We can't use output_bfd->section_count here to find the top output
11096      section index as some sections may have been removed, and
11097      strip_excluded_output_sections doesn't renumber the indices.  */
11098   for (section = info->output_bfd->sections, top_index = 0;
11099        section != NULL;
11100        section = section->next)
11101     {
11102       if (top_index < section->index)
11103         top_index = section->index;
11104     }
11105
11106   htab->top_index = top_index;
11107   amt = sizeof (asection *) * (top_index + 1);
11108   input_list = bfd_zmalloc (amt);
11109   htab->input_list = input_list;
11110   if (input_list == NULL)
11111     return -1;
11112
11113   return 1;
11114 }
11115
11116 /* Set up for first pass at multitoc partitioning.  */
11117
11118 void
11119 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11120 {
11121   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11122
11123   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11124   htab->toc_bfd = NULL;
11125   htab->toc_first_sec = NULL;
11126 }
11127
11128 /* The linker repeatedly calls this function for each TOC input section
11129    and linker generated GOT section.  Group input bfds such that the toc
11130    within a group is less than 64k in size.  */
11131
11132 bfd_boolean
11133 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11134 {
11135   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11136   bfd_vma addr, off, limit;
11137
11138   if (htab == NULL)
11139     return FALSE;
11140
11141   if (!htab->second_toc_pass)
11142     {
11143       /* Keep track of the first .toc or .got section for this input bfd.  */
11144       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11145
11146       if (new_bfd)
11147         {
11148           htab->toc_bfd = isec->owner;
11149           htab->toc_first_sec = isec;
11150         }
11151
11152       addr = isec->output_offset + isec->output_section->vma;
11153       off = addr - htab->toc_curr;
11154       limit = 0x80008000;
11155       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11156         limit = 0x10000;
11157       if (off + isec->size > limit)
11158         {
11159           addr = (htab->toc_first_sec->output_offset
11160                   + htab->toc_first_sec->output_section->vma);
11161           htab->toc_curr = addr;
11162         }
11163
11164       /* toc_curr is the base address of this toc group.  Set elf_gp
11165          for the input section to be the offset relative to the
11166          output toc base plus 0x8000.  Making the input elf_gp an
11167          offset allows us to move the toc as a whole without
11168          recalculating input elf_gp.  */
11169       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11170       off += TOC_BASE_OFF;
11171
11172       /* Die if someone uses a linker script that doesn't keep input
11173          file .toc and .got together.  */
11174       if (new_bfd
11175           && elf_gp (isec->owner) != 0
11176           && elf_gp (isec->owner) != off)
11177         return FALSE;
11178
11179       elf_gp (isec->owner) = off;
11180       return TRUE;
11181     }
11182
11183   /* During the second pass toc_first_sec points to the start of
11184      a toc group, and toc_curr is used to track the old elf_gp.
11185      We use toc_bfd to ensure we only look at each bfd once.  */
11186   if (htab->toc_bfd == isec->owner)
11187     return TRUE;
11188   htab->toc_bfd = isec->owner;
11189
11190   if (htab->toc_first_sec == NULL
11191       || htab->toc_curr != elf_gp (isec->owner))
11192     {
11193       htab->toc_curr = elf_gp (isec->owner);
11194       htab->toc_first_sec = isec;
11195     }
11196   addr = (htab->toc_first_sec->output_offset
11197           + htab->toc_first_sec->output_section->vma);
11198   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11199   elf_gp (isec->owner) = off;
11200
11201   return TRUE;
11202 }
11203
11204 /* Called via elf_link_hash_traverse to merge GOT entries for global
11205    symbol H.  */
11206
11207 static bfd_boolean
11208 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11209 {
11210   if (h->root.type == bfd_link_hash_indirect)
11211     return TRUE;
11212
11213   merge_got_entries (&h->got.glist);
11214
11215   return TRUE;
11216 }
11217
11218 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11219    symbol H.  */
11220
11221 static bfd_boolean
11222 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11223 {
11224   struct got_entry *gent;
11225
11226   if (h->root.type == bfd_link_hash_indirect)
11227     return TRUE;
11228
11229   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11230     if (!gent->is_indirect)
11231       allocate_got (h, (struct bfd_link_info *) inf, gent);
11232   return TRUE;
11233 }
11234
11235 /* Called on the first multitoc pass after the last call to
11236    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11237    entries.  */
11238
11239 bfd_boolean
11240 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11241 {
11242   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11243   struct bfd *ibfd, *ibfd2;
11244   bfd_boolean done_something;
11245
11246   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11247
11248   if (!htab->do_multi_toc)
11249     return FALSE;
11250
11251   /* Merge global sym got entries within a toc group.  */
11252   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11253
11254   /* And tlsld_got.  */
11255   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11256     {
11257       struct got_entry *ent, *ent2;
11258
11259       if (!is_ppc64_elf (ibfd))
11260         continue;
11261
11262       ent = ppc64_tlsld_got (ibfd);
11263       if (!ent->is_indirect
11264           && ent->got.offset != (bfd_vma) -1)
11265         {
11266           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11267             {
11268               if (!is_ppc64_elf (ibfd2))
11269                 continue;
11270
11271               ent2 = ppc64_tlsld_got (ibfd2);
11272               if (!ent2->is_indirect
11273                   && ent2->got.offset != (bfd_vma) -1
11274                   && elf_gp (ibfd2) == elf_gp (ibfd))
11275                 {
11276                   ent2->is_indirect = TRUE;
11277                   ent2->got.ent = ent;
11278                 }
11279             }
11280         }
11281     }
11282
11283   /* Zap sizes of got sections.  */
11284   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11285   htab->elf.irelplt->size -= htab->got_reli_size;
11286   htab->got_reli_size = 0;
11287
11288   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11289     {
11290       asection *got, *relgot;
11291
11292       if (!is_ppc64_elf (ibfd))
11293         continue;
11294
11295       got = ppc64_elf_tdata (ibfd)->got;
11296       if (got != NULL)
11297         {
11298           got->rawsize = got->size;
11299           got->size = 0;
11300           relgot = ppc64_elf_tdata (ibfd)->relgot;
11301           relgot->rawsize = relgot->size;
11302           relgot->size = 0;
11303         }
11304     }
11305
11306   /* Now reallocate the got, local syms first.  We don't need to
11307      allocate section contents again since we never increase size.  */
11308   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11309     {
11310       struct got_entry **lgot_ents;
11311       struct got_entry **end_lgot_ents;
11312       struct plt_entry **local_plt;
11313       struct plt_entry **end_local_plt;
11314       unsigned char *lgot_masks;
11315       bfd_size_type locsymcount;
11316       Elf_Internal_Shdr *symtab_hdr;
11317       asection *s;
11318
11319       if (!is_ppc64_elf (ibfd))
11320         continue;
11321
11322       lgot_ents = elf_local_got_ents (ibfd);
11323       if (!lgot_ents)
11324         continue;
11325
11326       symtab_hdr = &elf_symtab_hdr (ibfd);
11327       locsymcount = symtab_hdr->sh_info;
11328       end_lgot_ents = lgot_ents + locsymcount;
11329       local_plt = (struct plt_entry **) end_lgot_ents;
11330       end_local_plt = local_plt + locsymcount;
11331       lgot_masks = (unsigned char *) end_local_plt;
11332       s = ppc64_elf_tdata (ibfd)->got;
11333       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11334         {
11335           struct got_entry *ent;
11336
11337           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11338             {
11339               unsigned int ent_size = 8;
11340               unsigned int rel_size = sizeof (Elf64_External_Rela);
11341
11342               ent->got.offset = s->size;
11343               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11344                 {
11345                   ent_size *= 2;
11346                   rel_size *= 2;
11347                 }
11348               s->size += ent_size;
11349               if ((*lgot_masks & PLT_IFUNC) != 0)
11350                 {
11351                   htab->elf.irelplt->size += rel_size;
11352                   htab->got_reli_size += rel_size;
11353                 }
11354               else if (info->shared)
11355                 {
11356                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11357                   srel->size += rel_size;
11358                 }
11359             }
11360         }
11361     }
11362
11363   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11364
11365   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11366     {
11367       struct got_entry *ent;
11368
11369       if (!is_ppc64_elf (ibfd))
11370         continue;
11371
11372       ent = ppc64_tlsld_got (ibfd);
11373       if (!ent->is_indirect
11374           && ent->got.offset != (bfd_vma) -1)
11375         {
11376           asection *s = ppc64_elf_tdata (ibfd)->got;
11377           ent->got.offset = s->size;
11378           s->size += 16;
11379           if (info->shared)
11380             {
11381               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11382               srel->size += sizeof (Elf64_External_Rela);
11383             }
11384         }
11385     }
11386
11387   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11388   if (!done_something)
11389     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11390       {
11391         asection *got;
11392
11393         if (!is_ppc64_elf (ibfd))
11394           continue;
11395
11396         got = ppc64_elf_tdata (ibfd)->got;
11397         if (got != NULL)
11398           {
11399             done_something = got->rawsize != got->size;
11400             if (done_something)
11401               break;
11402           }
11403       }
11404
11405   if (done_something)
11406     (*htab->params->layout_sections_again) ();
11407
11408   /* Set up for second pass over toc sections to recalculate elf_gp
11409      on input sections.  */
11410   htab->toc_bfd = NULL;
11411   htab->toc_first_sec = NULL;
11412   htab->second_toc_pass = TRUE;
11413   return done_something;
11414 }
11415
11416 /* Called after second pass of multitoc partitioning.  */
11417
11418 void
11419 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11420 {
11421   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11422
11423   /* After the second pass, toc_curr tracks the TOC offset used
11424      for code sections below in ppc64_elf_next_input_section.  */
11425   htab->toc_curr = TOC_BASE_OFF;
11426 }
11427
11428 /* No toc references were found in ISEC.  If the code in ISEC makes no
11429    calls, then there's no need to use toc adjusting stubs when branching
11430    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11431    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11432    needed, and 2 if a cyclical call-graph was found but no other reason
11433    for a stub was detected.  If called from the top level, a return of
11434    2 means the same as a return of 0.  */
11435
11436 static int
11437 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11438 {
11439   int ret;
11440
11441   /* Mark this section as checked.  */
11442   isec->call_check_done = 1;
11443
11444   /* We know none of our code bearing sections will need toc stubs.  */
11445   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11446     return 0;
11447
11448   if (isec->size == 0)
11449     return 0;
11450
11451   if (isec->output_section == NULL)
11452     return 0;
11453
11454   ret = 0;
11455   if (isec->reloc_count != 0)
11456     {
11457       Elf_Internal_Rela *relstart, *rel;
11458       Elf_Internal_Sym *local_syms;
11459       struct ppc_link_hash_table *htab;
11460
11461       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11462                                             info->keep_memory);
11463       if (relstart == NULL)
11464         return -1;
11465
11466       /* Look for branches to outside of this section.  */
11467       local_syms = NULL;
11468       htab = ppc_hash_table (info);
11469       if (htab == NULL)
11470         return -1;
11471
11472       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11473         {
11474           enum elf_ppc64_reloc_type r_type;
11475           unsigned long r_symndx;
11476           struct elf_link_hash_entry *h;
11477           struct ppc_link_hash_entry *eh;
11478           Elf_Internal_Sym *sym;
11479           asection *sym_sec;
11480           struct _opd_sec_data *opd;
11481           bfd_vma sym_value;
11482           bfd_vma dest;
11483
11484           r_type = ELF64_R_TYPE (rel->r_info);
11485           if (r_type != R_PPC64_REL24
11486               && r_type != R_PPC64_REL14
11487               && r_type != R_PPC64_REL14_BRTAKEN
11488               && r_type != R_PPC64_REL14_BRNTAKEN)
11489             continue;
11490
11491           r_symndx = ELF64_R_SYM (rel->r_info);
11492           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11493                           isec->owner))
11494             {
11495               ret = -1;
11496               break;
11497             }
11498
11499           /* Calls to dynamic lib functions go through a plt call stub
11500              that uses r2.  */
11501           eh = (struct ppc_link_hash_entry *) h;
11502           if (eh != NULL
11503               && (eh->elf.plt.plist != NULL
11504                   || (eh->oh != NULL
11505                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11506             {
11507               ret = 1;
11508               break;
11509             }
11510
11511           if (sym_sec == NULL)
11512             /* Ignore other undefined symbols.  */
11513             continue;
11514
11515           /* Assume branches to other sections not included in the
11516              link need stubs too, to cover -R and absolute syms.  */
11517           if (sym_sec->output_section == NULL)
11518             {
11519               ret = 1;
11520               break;
11521             }
11522
11523           if (h == NULL)
11524             sym_value = sym->st_value;
11525           else
11526             {
11527               if (h->root.type != bfd_link_hash_defined
11528                   && h->root.type != bfd_link_hash_defweak)
11529                 abort ();
11530               sym_value = h->root.u.def.value;
11531             }
11532           sym_value += rel->r_addend;
11533
11534           /* If this branch reloc uses an opd sym, find the code section.  */
11535           opd = get_opd_info (sym_sec);
11536           if (opd != NULL)
11537             {
11538               if (h == NULL && opd->adjust != NULL)
11539                 {
11540                   long adjust;
11541
11542                   adjust = opd->adjust[sym->st_value / 8];
11543                   if (adjust == -1)
11544                     /* Assume deleted functions won't ever be called.  */
11545                     continue;
11546                   sym_value += adjust;
11547                 }
11548
11549               dest = opd_entry_value (sym_sec, sym_value,
11550                                       &sym_sec, NULL, FALSE);
11551               if (dest == (bfd_vma) -1)
11552                 continue;
11553             }
11554           else
11555             dest = (sym_value
11556                     + sym_sec->output_offset
11557                     + sym_sec->output_section->vma);
11558
11559           /* Ignore branch to self.  */
11560           if (sym_sec == isec)
11561             continue;
11562
11563           /* If the called function uses the toc, we need a stub.  */
11564           if (sym_sec->has_toc_reloc
11565               || sym_sec->makes_toc_func_call)
11566             {
11567               ret = 1;
11568               break;
11569             }
11570
11571           /* Assume any branch that needs a long branch stub might in fact
11572              need a plt_branch stub.  A plt_branch stub uses r2.  */
11573           else if (dest - (isec->output_offset
11574                            + isec->output_section->vma
11575                            + rel->r_offset) + (1 << 25)
11576                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11577                                                              ? h->other
11578                                                              : sym->st_other))
11579             {
11580               ret = 1;
11581               break;
11582             }
11583
11584           /* If calling back to a section in the process of being
11585              tested, we can't say for sure that no toc adjusting stubs
11586              are needed, so don't return zero.  */
11587           else if (sym_sec->call_check_in_progress)
11588             ret = 2;
11589
11590           /* Branches to another section that itself doesn't have any TOC
11591              references are OK.  Recursively call ourselves to check.  */
11592           else if (!sym_sec->call_check_done)
11593             {
11594               int recur;
11595
11596               /* Mark current section as indeterminate, so that other
11597                  sections that call back to current won't be marked as
11598                  known.  */
11599               isec->call_check_in_progress = 1;
11600               recur = toc_adjusting_stub_needed (info, sym_sec);
11601               isec->call_check_in_progress = 0;
11602
11603               if (recur != 0)
11604                 {
11605                   ret = recur;
11606                   if (recur != 2)
11607                     break;
11608                 }
11609             }
11610         }
11611
11612       if (local_syms != NULL
11613           && (elf_symtab_hdr (isec->owner).contents
11614               != (unsigned char *) local_syms))
11615         free (local_syms);
11616       if (elf_section_data (isec)->relocs != relstart)
11617         free (relstart);
11618     }
11619
11620   if ((ret & 1) == 0
11621       && isec->map_head.s != NULL
11622       && (strcmp (isec->output_section->name, ".init") == 0
11623           || strcmp (isec->output_section->name, ".fini") == 0))
11624     {
11625       if (isec->map_head.s->has_toc_reloc
11626           || isec->map_head.s->makes_toc_func_call)
11627         ret = 1;
11628       else if (!isec->map_head.s->call_check_done)
11629         {
11630           int recur;
11631           isec->call_check_in_progress = 1;
11632           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11633           isec->call_check_in_progress = 0;
11634           if (recur != 0)
11635             ret = recur;
11636         }
11637     }
11638
11639   if (ret == 1)
11640     isec->makes_toc_func_call = 1;
11641
11642   return ret;
11643 }
11644
11645 /* The linker repeatedly calls this function for each input section,
11646    in the order that input sections are linked into output sections.
11647    Build lists of input sections to determine groupings between which
11648    we may insert linker stubs.  */
11649
11650 bfd_boolean
11651 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11652 {
11653   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11654
11655   if (htab == NULL)
11656     return FALSE;
11657
11658   if ((isec->output_section->flags & SEC_CODE) != 0
11659       && isec->output_section->index <= htab->top_index)
11660     {
11661       asection **list = htab->input_list + isec->output_section->index;
11662       /* Steal the link_sec pointer for our list.  */
11663 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11664       /* This happens to make the list in reverse order,
11665          which is what we want.  */
11666       PREV_SEC (isec) = *list;
11667       *list = isec;
11668     }
11669
11670   if (htab->multi_toc_needed)
11671     {
11672       /* Analyse sections that aren't already flagged as needing a
11673          valid toc pointer.  Exclude .fixup for the linux kernel.
11674          .fixup contains branches, but only back to the function that
11675          hit an exception.  */
11676       if (!(isec->has_toc_reloc
11677             || (isec->flags & SEC_CODE) == 0
11678             || strcmp (isec->name, ".fixup") == 0
11679             || isec->call_check_done))
11680         {
11681           if (toc_adjusting_stub_needed (info, isec) < 0)
11682             return FALSE;
11683         }
11684       /* Make all sections use the TOC assigned for this object file.
11685          This will be wrong for pasted sections;  We fix that in
11686          check_pasted_section().  */
11687       if (elf_gp (isec->owner) != 0)
11688         htab->toc_curr = elf_gp (isec->owner);
11689     }
11690
11691   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11692   return TRUE;
11693 }
11694
11695 /* Check that all .init and .fini sections use the same toc, if they
11696    have toc relocs.  */
11697
11698 static bfd_boolean
11699 check_pasted_section (struct bfd_link_info *info, const char *name)
11700 {
11701   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11702
11703   if (o != NULL)
11704     {
11705       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11706       bfd_vma toc_off = 0;
11707       asection *i;
11708
11709       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11710         if (i->has_toc_reloc)
11711           {
11712             if (toc_off == 0)
11713               toc_off = htab->stub_group[i->id].toc_off;
11714             else if (toc_off != htab->stub_group[i->id].toc_off)
11715               return FALSE;
11716           }
11717
11718       if (toc_off == 0)
11719         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11720           if (i->makes_toc_func_call)
11721             {
11722               toc_off = htab->stub_group[i->id].toc_off;
11723               break;
11724             }
11725
11726       /* Make sure the whole pasted function uses the same toc offset.  */
11727       if (toc_off != 0)
11728         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11729           htab->stub_group[i->id].toc_off = toc_off;
11730     }
11731   return TRUE;
11732 }
11733
11734 bfd_boolean
11735 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11736 {
11737   return (check_pasted_section (info, ".init")
11738           & check_pasted_section (info, ".fini"));
11739 }
11740
11741 /* See whether we can group stub sections together.  Grouping stub
11742    sections may result in fewer stubs.  More importantly, we need to
11743    put all .init* and .fini* stubs at the beginning of the .init or
11744    .fini output sections respectively, because glibc splits the
11745    _init and _fini functions into multiple parts.  Putting a stub in
11746    the middle of a function is not a good idea.  */
11747
11748 static void
11749 group_sections (struct ppc_link_hash_table *htab,
11750                 bfd_size_type stub_group_size,
11751                 bfd_boolean stubs_always_before_branch)
11752 {
11753   asection **list;
11754   bfd_size_type stub14_group_size;
11755   bfd_boolean suppress_size_errors;
11756
11757   suppress_size_errors = FALSE;
11758   stub14_group_size = stub_group_size;
11759   if (stub_group_size == 1)
11760     {
11761       /* Default values.  */
11762       if (stubs_always_before_branch)
11763         {
11764           stub_group_size = 0x1e00000;
11765           stub14_group_size = 0x7800;
11766         }
11767       else
11768         {
11769           stub_group_size = 0x1c00000;
11770           stub14_group_size = 0x7000;
11771         }
11772       suppress_size_errors = TRUE;
11773     }
11774
11775   list = htab->input_list + htab->top_index;
11776   do
11777     {
11778       asection *tail = *list;
11779       while (tail != NULL)
11780         {
11781           asection *curr;
11782           asection *prev;
11783           bfd_size_type total;
11784           bfd_boolean big_sec;
11785           bfd_vma curr_toc;
11786
11787           curr = tail;
11788           total = tail->size;
11789           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11790                              && ppc64_elf_section_data (tail)->has_14bit_branch
11791                              ? stub14_group_size : stub_group_size);
11792           if (big_sec && !suppress_size_errors)
11793             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11794                                      tail->owner, tail);
11795           curr_toc = htab->stub_group[tail->id].toc_off;
11796
11797           while ((prev = PREV_SEC (curr)) != NULL
11798                  && ((total += curr->output_offset - prev->output_offset)
11799                      < (ppc64_elf_section_data (prev) != NULL
11800                         && ppc64_elf_section_data (prev)->has_14bit_branch
11801                         ? stub14_group_size : stub_group_size))
11802                  && htab->stub_group[prev->id].toc_off == curr_toc)
11803             curr = prev;
11804
11805           /* OK, the size from the start of CURR to the end is less
11806              than stub_group_size and thus can be handled by one stub
11807              section.  (or the tail section is itself larger than
11808              stub_group_size, in which case we may be toast.)  We
11809              should really be keeping track of the total size of stubs
11810              added here, as stubs contribute to the final output
11811              section size.  That's a little tricky, and this way will
11812              only break if stubs added make the total size more than
11813              2^25, ie. for the default stub_group_size, if stubs total
11814              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11815           do
11816             {
11817               prev = PREV_SEC (tail);
11818               /* Set up this stub group.  */
11819               htab->stub_group[tail->id].link_sec = curr;
11820             }
11821           while (tail != curr && (tail = prev) != NULL);
11822
11823           /* But wait, there's more!  Input sections up to stub_group_size
11824              bytes before the stub section can be handled by it too.
11825              Don't do this if we have a really large section after the
11826              stubs, as adding more stubs increases the chance that
11827              branches may not reach into the stub section.  */
11828           if (!stubs_always_before_branch && !big_sec)
11829             {
11830               total = 0;
11831               while (prev != NULL
11832                      && ((total += tail->output_offset - prev->output_offset)
11833                          < (ppc64_elf_section_data (prev) != NULL
11834                             && ppc64_elf_section_data (prev)->has_14bit_branch
11835                             ? stub14_group_size : stub_group_size))
11836                      && htab->stub_group[prev->id].toc_off == curr_toc)
11837                 {
11838                   tail = prev;
11839                   prev = PREV_SEC (tail);
11840                   htab->stub_group[tail->id].link_sec = curr;
11841                 }
11842             }
11843           tail = prev;
11844         }
11845     }
11846   while (list-- != htab->input_list);
11847   free (htab->input_list);
11848 #undef PREV_SEC
11849 }
11850
11851 static const unsigned char glink_eh_frame_cie[] =
11852 {
11853   0, 0, 0, 16,                          /* length.  */
11854   0, 0, 0, 0,                           /* id.  */
11855   1,                                    /* CIE version.  */
11856   'z', 'R', 0,                          /* Augmentation string.  */
11857   4,                                    /* Code alignment.  */
11858   0x78,                                 /* Data alignment.  */
11859   65,                                   /* RA reg.  */
11860   1,                                    /* Augmentation size.  */
11861   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11862   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11863 };
11864
11865 /* Stripping output sections is normally done before dynamic section
11866    symbols have been allocated.  This function is called later, and
11867    handles cases like htab->brlt which is mapped to its own output
11868    section.  */
11869
11870 static void
11871 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11872 {
11873   if (isec->size == 0
11874       && isec->output_section->size == 0
11875       && !(isec->output_section->flags & SEC_KEEP)
11876       && !bfd_section_removed_from_list (info->output_bfd,
11877                                          isec->output_section)
11878       && elf_section_data (isec->output_section)->dynindx == 0)
11879     {
11880       isec->output_section->flags |= SEC_EXCLUDE;
11881       bfd_section_list_remove (info->output_bfd, isec->output_section);
11882       info->output_bfd->section_count--;
11883     }
11884 }
11885
11886 /* Determine and set the size of the stub section for a final link.
11887
11888    The basic idea here is to examine all the relocations looking for
11889    PC-relative calls to a target that is unreachable with a "bl"
11890    instruction.  */
11891
11892 bfd_boolean
11893 ppc64_elf_size_stubs (struct bfd_link_info *info)
11894 {
11895   bfd_size_type stub_group_size;
11896   bfd_boolean stubs_always_before_branch;
11897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11898
11899   if (htab == NULL)
11900     return FALSE;
11901
11902   if (htab->params->plt_thread_safe == -1 && !info->executable)
11903     htab->params->plt_thread_safe = 1;
11904   if (!htab->opd_abi)
11905     htab->params->plt_thread_safe = 0;
11906   else if (htab->params->plt_thread_safe == -1)
11907     {
11908       static const char *const thread_starter[] =
11909         {
11910           "pthread_create",
11911           /* libstdc++ */
11912           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11913           /* librt */
11914           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11915           "mq_notify", "create_timer",
11916           /* libanl */
11917           "getaddrinfo_a",
11918           /* libgomp */
11919           "GOMP_parallel_start",
11920           "GOMP_parallel_loop_static_start",
11921           "GOMP_parallel_loop_dynamic_start",
11922           "GOMP_parallel_loop_guided_start",
11923           "GOMP_parallel_loop_runtime_start",
11924           "GOMP_parallel_sections_start",
11925         };
11926       unsigned i;
11927
11928       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11929         {
11930           struct elf_link_hash_entry *h;
11931           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11932                                     FALSE, FALSE, TRUE);
11933           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11934           if (htab->params->plt_thread_safe)
11935             break;
11936         }
11937     }
11938   stubs_always_before_branch = htab->params->group_size < 0;
11939   if (htab->params->group_size < 0)
11940     stub_group_size = -htab->params->group_size;
11941   else
11942     stub_group_size = htab->params->group_size;
11943
11944   group_sections (htab, stub_group_size, stubs_always_before_branch);
11945
11946   while (1)
11947     {
11948       bfd *input_bfd;
11949       unsigned int bfd_indx;
11950       asection *stub_sec;
11951
11952       htab->stub_iteration += 1;
11953
11954       for (input_bfd = info->input_bfds, bfd_indx = 0;
11955            input_bfd != NULL;
11956            input_bfd = input_bfd->link_next, bfd_indx++)
11957         {
11958           Elf_Internal_Shdr *symtab_hdr;
11959           asection *section;
11960           Elf_Internal_Sym *local_syms = NULL;
11961
11962           if (!is_ppc64_elf (input_bfd))
11963             continue;
11964
11965           /* We'll need the symbol table in a second.  */
11966           symtab_hdr = &elf_symtab_hdr (input_bfd);
11967           if (symtab_hdr->sh_info == 0)
11968             continue;
11969
11970           /* Walk over each section attached to the input bfd.  */
11971           for (section = input_bfd->sections;
11972                section != NULL;
11973                section = section->next)
11974             {
11975               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11976
11977               /* If there aren't any relocs, then there's nothing more
11978                  to do.  */
11979               if ((section->flags & SEC_RELOC) == 0
11980                   || (section->flags & SEC_ALLOC) == 0
11981                   || (section->flags & SEC_LOAD) == 0
11982                   || (section->flags & SEC_CODE) == 0
11983                   || section->reloc_count == 0)
11984                 continue;
11985
11986               /* If this section is a link-once section that will be
11987                  discarded, then don't create any stubs.  */
11988               if (section->output_section == NULL
11989                   || section->output_section->owner != info->output_bfd)
11990                 continue;
11991
11992               /* Get the relocs.  */
11993               internal_relocs
11994                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11995                                              info->keep_memory);
11996               if (internal_relocs == NULL)
11997                 goto error_ret_free_local;
11998
11999               /* Now examine each relocation.  */
12000               irela = internal_relocs;
12001               irelaend = irela + section->reloc_count;
12002               for (; irela < irelaend; irela++)
12003                 {
12004                   enum elf_ppc64_reloc_type r_type;
12005                   unsigned int r_indx;
12006                   enum ppc_stub_type stub_type;
12007                   struct ppc_stub_hash_entry *stub_entry;
12008                   asection *sym_sec, *code_sec;
12009                   bfd_vma sym_value, code_value;
12010                   bfd_vma destination;
12011                   unsigned long local_off;
12012                   bfd_boolean ok_dest;
12013                   struct ppc_link_hash_entry *hash;
12014                   struct ppc_link_hash_entry *fdh;
12015                   struct elf_link_hash_entry *h;
12016                   Elf_Internal_Sym *sym;
12017                   char *stub_name;
12018                   const asection *id_sec;
12019                   struct _opd_sec_data *opd;
12020                   struct plt_entry *plt_ent;
12021
12022                   r_type = ELF64_R_TYPE (irela->r_info);
12023                   r_indx = ELF64_R_SYM (irela->r_info);
12024
12025                   if (r_type >= R_PPC64_max)
12026                     {
12027                       bfd_set_error (bfd_error_bad_value);
12028                       goto error_ret_free_internal;
12029                     }
12030
12031                   /* Only look for stubs on branch instructions.  */
12032                   if (r_type != R_PPC64_REL24
12033                       && r_type != R_PPC64_REL14
12034                       && r_type != R_PPC64_REL14_BRTAKEN
12035                       && r_type != R_PPC64_REL14_BRNTAKEN)
12036                     continue;
12037
12038                   /* Now determine the call target, its name, value,
12039                      section.  */
12040                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12041                                   r_indx, input_bfd))
12042                     goto error_ret_free_internal;
12043                   hash = (struct ppc_link_hash_entry *) h;
12044
12045                   ok_dest = FALSE;
12046                   fdh = NULL;
12047                   sym_value = 0;
12048                   if (hash == NULL)
12049                     {
12050                       sym_value = sym->st_value;
12051                       ok_dest = TRUE;
12052                     }
12053                   else if (hash->elf.root.type == bfd_link_hash_defined
12054                            || hash->elf.root.type == bfd_link_hash_defweak)
12055                     {
12056                       sym_value = hash->elf.root.u.def.value;
12057                       if (sym_sec->output_section != NULL)
12058                         ok_dest = TRUE;
12059                     }
12060                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12061                            || hash->elf.root.type == bfd_link_hash_undefined)
12062                     {
12063                       /* Recognise an old ABI func code entry sym, and
12064                          use the func descriptor sym instead if it is
12065                          defined.  */
12066                       if (hash->elf.root.root.string[0] == '.'
12067                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12068                         {
12069                           if (fdh->elf.root.type == bfd_link_hash_defined
12070                               || fdh->elf.root.type == bfd_link_hash_defweak)
12071                             {
12072                               sym_sec = fdh->elf.root.u.def.section;
12073                               sym_value = fdh->elf.root.u.def.value;
12074                               if (sym_sec->output_section != NULL)
12075                                 ok_dest = TRUE;
12076                             }
12077                           else
12078                             fdh = NULL;
12079                         }
12080                     }
12081                   else
12082                     {
12083                       bfd_set_error (bfd_error_bad_value);
12084                       goto error_ret_free_internal;
12085                     }
12086
12087                   destination = 0;
12088                   local_off = 0;
12089                   if (ok_dest)
12090                     {
12091                       sym_value += irela->r_addend;
12092                       destination = (sym_value
12093                                      + sym_sec->output_offset
12094                                      + sym_sec->output_section->vma);
12095                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12096                                                             ? hash->elf.other
12097                                                             : sym->st_other);
12098                     }
12099
12100                   code_sec = sym_sec;
12101                   code_value = sym_value;
12102                   opd = get_opd_info (sym_sec);
12103                   if (opd != NULL)
12104                     {
12105                       bfd_vma dest;
12106
12107                       if (hash == NULL && opd->adjust != NULL)
12108                         {
12109                           long adjust = opd->adjust[sym_value / 8];
12110                           if (adjust == -1)
12111                             continue;
12112                           code_value += adjust;
12113                           sym_value += adjust;
12114                         }
12115                       dest = opd_entry_value (sym_sec, sym_value,
12116                                               &code_sec, &code_value, FALSE);
12117                       if (dest != (bfd_vma) -1)
12118                         {
12119                           destination = dest;
12120                           if (fdh != NULL)
12121                             {
12122                               /* Fixup old ABI sym to point at code
12123                                  entry.  */
12124                               hash->elf.root.type = bfd_link_hash_defweak;
12125                               hash->elf.root.u.def.section = code_sec;
12126                               hash->elf.root.u.def.value = code_value;
12127                             }
12128                         }
12129                     }
12130
12131                   /* Determine what (if any) linker stub is needed.  */
12132                   plt_ent = NULL;
12133                   stub_type = ppc_type_of_stub (section, irela, &hash,
12134                                                 &plt_ent, destination,
12135                                                 local_off);
12136
12137                   if (stub_type != ppc_stub_plt_call)
12138                     {
12139                       /* Check whether we need a TOC adjusting stub.
12140                          Since the linker pastes together pieces from
12141                          different object files when creating the
12142                          _init and _fini functions, it may be that a
12143                          call to what looks like a local sym is in
12144                          fact a call needing a TOC adjustment.  */
12145                       if (code_sec != NULL
12146                           && code_sec->output_section != NULL
12147                           && (htab->stub_group[code_sec->id].toc_off
12148                               != htab->stub_group[section->id].toc_off)
12149                           && (code_sec->has_toc_reloc
12150                               || code_sec->makes_toc_func_call))
12151                         stub_type = ppc_stub_long_branch_r2off;
12152                     }
12153
12154                   if (stub_type == ppc_stub_none)
12155                     continue;
12156
12157                   /* __tls_get_addr calls might be eliminated.  */
12158                   if (stub_type != ppc_stub_plt_call
12159                       && hash != NULL
12160                       && (hash == htab->tls_get_addr
12161                           || hash == htab->tls_get_addr_fd)
12162                       && section->has_tls_reloc
12163                       && irela != internal_relocs)
12164                     {
12165                       /* Get tls info.  */
12166                       unsigned char *tls_mask;
12167
12168                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12169                                          irela - 1, input_bfd))
12170                         goto error_ret_free_internal;
12171                       if (*tls_mask != 0)
12172                         continue;
12173                     }
12174
12175                   if (stub_type == ppc_stub_plt_call
12176                       && irela + 1 < irelaend
12177                       && irela[1].r_offset == irela->r_offset + 4
12178                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12179                     {
12180                       if (!tocsave_find (htab, INSERT,
12181                                          &local_syms, irela + 1, input_bfd))
12182                         goto error_ret_free_internal;
12183                     }
12184                   else if (stub_type == ppc_stub_plt_call)
12185                     stub_type = ppc_stub_plt_call_r2save;
12186
12187                   /* Support for grouping stub sections.  */
12188                   id_sec = htab->stub_group[section->id].link_sec;
12189
12190                   /* Get the name of this stub.  */
12191                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12192                   if (!stub_name)
12193                     goto error_ret_free_internal;
12194
12195                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12196                                                      stub_name, FALSE, FALSE);
12197                   if (stub_entry != NULL)
12198                     {
12199                       /* The proper stub has already been created.  */
12200                       free (stub_name);
12201                       if (stub_type == ppc_stub_plt_call_r2save)
12202                         stub_entry->stub_type = stub_type;
12203                       continue;
12204                     }
12205
12206                   stub_entry = ppc_add_stub (stub_name, section, info);
12207                   if (stub_entry == NULL)
12208                     {
12209                       free (stub_name);
12210                     error_ret_free_internal:
12211                       if (elf_section_data (section)->relocs == NULL)
12212                         free (internal_relocs);
12213                     error_ret_free_local:
12214                       if (local_syms != NULL
12215                           && (symtab_hdr->contents
12216                               != (unsigned char *) local_syms))
12217                         free (local_syms);
12218                       return FALSE;
12219                     }
12220
12221                   stub_entry->stub_type = stub_type;
12222                   if (stub_type != ppc_stub_plt_call
12223                       && stub_type != ppc_stub_plt_call_r2save)
12224                     {
12225                       stub_entry->target_value = code_value;
12226                       stub_entry->target_section = code_sec;
12227                     }
12228                   else
12229                     {
12230                       stub_entry->target_value = sym_value;
12231                       stub_entry->target_section = sym_sec;
12232                     }
12233                   stub_entry->h = hash;
12234                   stub_entry->plt_ent = plt_ent;
12235                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12236
12237                   if (stub_entry->h != NULL)
12238                     htab->stub_globals += 1;
12239                 }
12240
12241               /* We're done with the internal relocs, free them.  */
12242               if (elf_section_data (section)->relocs != internal_relocs)
12243                 free (internal_relocs);
12244             }
12245
12246           if (local_syms != NULL
12247               && symtab_hdr->contents != (unsigned char *) local_syms)
12248             {
12249               if (!info->keep_memory)
12250                 free (local_syms);
12251               else
12252                 symtab_hdr->contents = (unsigned char *) local_syms;
12253             }
12254         }
12255
12256       /* We may have added some stubs.  Find out the new size of the
12257          stub sections.  */
12258       for (stub_sec = htab->params->stub_bfd->sections;
12259            stub_sec != NULL;
12260            stub_sec = stub_sec->next)
12261         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12262           {
12263             stub_sec->rawsize = stub_sec->size;
12264             stub_sec->size = 0;
12265             stub_sec->reloc_count = 0;
12266             stub_sec->flags &= ~SEC_RELOC;
12267           }
12268
12269       htab->brlt->size = 0;
12270       htab->brlt->reloc_count = 0;
12271       htab->brlt->flags &= ~SEC_RELOC;
12272       if (htab->relbrlt != NULL)
12273         htab->relbrlt->size = 0;
12274
12275       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12276
12277       if (info->emitrelocations
12278           && htab->glink != NULL && htab->glink->size != 0)
12279         {
12280           htab->glink->reloc_count = 1;
12281           htab->glink->flags |= SEC_RELOC;
12282         }
12283
12284       if (htab->glink_eh_frame != NULL
12285           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12286           && htab->glink_eh_frame->output_section->size != 0)
12287         {
12288           size_t size = 0, align;
12289
12290           for (stub_sec = htab->params->stub_bfd->sections;
12291                stub_sec != NULL;
12292                stub_sec = stub_sec->next)
12293             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12294               size += 20;
12295           if (htab->glink != NULL && htab->glink->size != 0)
12296             size += 24;
12297           if (size != 0)
12298             size += sizeof (glink_eh_frame_cie);
12299           align = 1;
12300           align <<= htab->glink_eh_frame->output_section->alignment_power;
12301           align -= 1;
12302           size = (size + align) & ~align;
12303           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12304           htab->glink_eh_frame->size = size;
12305         }
12306
12307       if (htab->params->plt_stub_align != 0)
12308         for (stub_sec = htab->params->stub_bfd->sections;
12309              stub_sec != NULL;
12310              stub_sec = stub_sec->next)
12311           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12312             stub_sec->size = ((stub_sec->size
12313                                + (1 << htab->params->plt_stub_align) - 1)
12314                               & (-1 << htab->params->plt_stub_align));
12315
12316       for (stub_sec = htab->params->stub_bfd->sections;
12317            stub_sec != NULL;
12318            stub_sec = stub_sec->next)
12319         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12320             && stub_sec->rawsize != stub_sec->size)
12321           break;
12322
12323       /* Exit from this loop when no stubs have been added, and no stubs
12324          have changed size.  */
12325       if (stub_sec == NULL
12326           && (htab->glink_eh_frame == NULL
12327               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12328         break;
12329
12330       /* Ask the linker to do its stuff.  */
12331       (*htab->params->layout_sections_again) ();
12332     }
12333
12334   maybe_strip_output (info, htab->brlt);
12335   if (htab->glink_eh_frame != NULL)
12336     maybe_strip_output (info, htab->glink_eh_frame);
12337
12338   return TRUE;
12339 }
12340
12341 /* Called after we have determined section placement.  If sections
12342    move, we'll be called again.  Provide a value for TOCstart.  */
12343
12344 bfd_vma
12345 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12346 {
12347   asection *s;
12348   bfd_vma TOCstart;
12349
12350   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12351      order.  The TOC starts where the first of these sections starts.  */
12352   s = bfd_get_section_by_name (obfd, ".got");
12353   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12354     s = bfd_get_section_by_name (obfd, ".toc");
12355   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12356     s = bfd_get_section_by_name (obfd, ".tocbss");
12357   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12358     s = bfd_get_section_by_name (obfd, ".plt");
12359   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12360     {
12361       /* This may happen for
12362          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12363          .toc directive
12364          o  bad linker script
12365          o --gc-sections and empty TOC sections
12366
12367          FIXME: Warn user?  */
12368
12369       /* Look for a likely section.  We probably won't even be
12370          using TOCstart.  */
12371       for (s = obfd->sections; s != NULL; s = s->next)
12372         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12373                          | SEC_EXCLUDE))
12374             == (SEC_ALLOC | SEC_SMALL_DATA))
12375           break;
12376       if (s == NULL)
12377         for (s = obfd->sections; s != NULL; s = s->next)
12378           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12379               == (SEC_ALLOC | SEC_SMALL_DATA))
12380             break;
12381       if (s == NULL)
12382         for (s = obfd->sections; s != NULL; s = s->next)
12383           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12384               == SEC_ALLOC)
12385             break;
12386       if (s == NULL)
12387         for (s = obfd->sections; s != NULL; s = s->next)
12388           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12389             break;
12390     }
12391
12392   TOCstart = 0;
12393   if (s != NULL)
12394     TOCstart = s->output_section->vma + s->output_offset;
12395
12396   _bfd_set_gp_value (obfd, TOCstart);
12397
12398   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12399     {
12400       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12401
12402       if (htab != NULL
12403           && htab->elf.hgot != NULL)
12404         {
12405           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12406           htab->elf.hgot->root.u.def.section = s;
12407         }
12408     }
12409   return TOCstart;
12410 }
12411
12412 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12413    write out any global entry stubs.  */
12414
12415 static bfd_boolean
12416 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12417 {
12418   struct bfd_link_info *info;
12419   struct ppc_link_hash_table *htab;
12420   struct plt_entry *pent;
12421   asection *s;
12422
12423   if (h->root.type == bfd_link_hash_indirect)
12424     return TRUE;
12425
12426   if (!h->pointer_equality_needed)
12427     return TRUE;
12428
12429   if (h->def_regular)
12430     return TRUE;
12431
12432   info = inf;
12433   htab = ppc_hash_table (info);
12434   if (htab == NULL)
12435     return FALSE;
12436
12437   s = htab->glink;
12438   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12439     if (pent->plt.offset != (bfd_vma) -1
12440         && pent->addend == 0)
12441       {
12442         bfd_byte *p;
12443         asection *plt;
12444         bfd_vma off;
12445
12446         p = s->contents + h->root.u.def.value;
12447         plt = htab->elf.splt;
12448         if (!htab->elf.dynamic_sections_created
12449             || h->dynindx == -1)
12450           plt = htab->elf.iplt;
12451         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12452         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12453
12454         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12455           {
12456             info->callbacks->einfo
12457               (_("%P: linkage table error against `%T'\n"),
12458                h->root.root.string);
12459             bfd_set_error (bfd_error_bad_value);
12460             htab->stub_error = TRUE;
12461           }
12462
12463         if (PPC_HA (off) != 0)
12464           {
12465             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12466             p += 4;
12467           }
12468         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12469         p += 4;
12470         bfd_put_32 (s->owner, MTCTR_R12, p);
12471         p += 4;
12472         bfd_put_32 (s->owner, BCTR, p);
12473         break;
12474       }
12475   return TRUE;
12476 }
12477
12478 /* Build all the stubs associated with the current output file.
12479    The stubs are kept in a hash table attached to the main linker
12480    hash table.  This function is called via gldelf64ppc_finish.  */
12481
12482 bfd_boolean
12483 ppc64_elf_build_stubs (struct bfd_link_info *info,
12484                        char **stats)
12485 {
12486   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12487   asection *stub_sec;
12488   bfd_byte *p;
12489   int stub_sec_count = 0;
12490
12491   if (htab == NULL)
12492     return FALSE;
12493
12494   /* Allocate memory to hold the linker stubs.  */
12495   for (stub_sec = htab->params->stub_bfd->sections;
12496        stub_sec != NULL;
12497        stub_sec = stub_sec->next)
12498     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12499         && stub_sec->size != 0)
12500       {
12501         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12502         if (stub_sec->contents == NULL)
12503           return FALSE;
12504         /* We want to check that built size is the same as calculated
12505            size.  rawsize is a convenient location to use.  */
12506         stub_sec->rawsize = stub_sec->size;
12507         stub_sec->size = 0;
12508       }
12509
12510   if (htab->glink != NULL && htab->glink->size != 0)
12511     {
12512       unsigned int indx;
12513       bfd_vma plt0;
12514
12515       /* Build the .glink plt call stub.  */
12516       if (htab->params->emit_stub_syms)
12517         {
12518           struct elf_link_hash_entry *h;
12519           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12520                                     TRUE, FALSE, FALSE);
12521           if (h == NULL)
12522             return FALSE;
12523           if (h->root.type == bfd_link_hash_new)
12524             {
12525               h->root.type = bfd_link_hash_defined;
12526               h->root.u.def.section = htab->glink;
12527               h->root.u.def.value = 8;
12528               h->ref_regular = 1;
12529               h->def_regular = 1;
12530               h->ref_regular_nonweak = 1;
12531               h->forced_local = 1;
12532               h->non_elf = 0;
12533             }
12534         }
12535       plt0 = (htab->elf.splt->output_section->vma
12536               + htab->elf.splt->output_offset
12537               - 16);
12538       if (info->emitrelocations)
12539         {
12540           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12541           if (r == NULL)
12542             return FALSE;
12543           r->r_offset = (htab->glink->output_offset
12544                          + htab->glink->output_section->vma);
12545           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12546           r->r_addend = plt0;
12547         }
12548       p = htab->glink->contents;
12549       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12550       bfd_put_64 (htab->glink->owner, plt0, p);
12551       p += 8;
12552       if (htab->opd_abi)
12553         {
12554           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12555           p += 4;
12556           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12557           p += 4;
12558           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12559           p += 4;
12560           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12561           p += 4;
12562           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12563           p += 4;
12564           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12565           p += 4;
12566           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12567           p += 4;
12568           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12569           p += 4;
12570           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12571           p += 4;
12572           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12573           p += 4;
12574         }
12575       else
12576         {
12577           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12578           p += 4;
12579           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12580           p += 4;
12581           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12582           p += 4;
12583           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12584           p += 4;
12585           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12586           p += 4;
12587           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12588           p += 4;
12589           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12590           p += 4;
12591           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12592           p += 4;
12593           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12594           p += 4;
12595           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12596           p += 4;
12597           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12598           p += 4;
12599           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12600           p += 4;
12601         }
12602       bfd_put_32 (htab->glink->owner, BCTR, p);
12603       p += 4;
12604       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12605         {
12606           bfd_put_32 (htab->glink->owner, NOP, p);
12607           p += 4;
12608         }
12609
12610       /* Build the .glink lazy link call stubs.  */
12611       indx = 0;
12612       while (p < htab->glink->contents + htab->glink->rawsize)
12613         {
12614           if (htab->opd_abi)
12615             {
12616               if (indx < 0x8000)
12617                 {
12618                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12619                   p += 4;
12620                 }
12621               else
12622                 {
12623                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12624                   p += 4;
12625                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12626                               p);
12627                   p += 4;
12628                 }
12629             }
12630           bfd_put_32 (htab->glink->owner,
12631                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12632           indx++;
12633           p += 4;
12634         }
12635
12636       /* Build .glink global entry stubs.  */
12637       if (htab->glink->size > htab->glink->rawsize)
12638         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12639     }
12640
12641   if (htab->brlt->size != 0)
12642     {
12643       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12644                                          htab->brlt->size);
12645       if (htab->brlt->contents == NULL)
12646         return FALSE;
12647     }
12648   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12649     {
12650       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12651                                             htab->relbrlt->size);
12652       if (htab->relbrlt->contents == NULL)
12653         return FALSE;
12654     }
12655
12656   if (htab->glink_eh_frame != NULL
12657       && htab->glink_eh_frame->size != 0)
12658     {
12659       bfd_vma val;
12660       bfd_byte *last_fde;
12661       size_t last_fde_len, size, align, pad;
12662
12663       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12664       if (p == NULL)
12665         return FALSE;
12666       htab->glink_eh_frame->contents = p;
12667       last_fde = p;
12668
12669       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12670
12671       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12672       /* CIE length (rewrite in case little-endian).  */
12673       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12674       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12675       p += sizeof (glink_eh_frame_cie);
12676
12677       for (stub_sec = htab->params->stub_bfd->sections;
12678            stub_sec != NULL;
12679            stub_sec = stub_sec->next)
12680         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12681           {
12682             last_fde = p;
12683             last_fde_len = 16;
12684             /* FDE length.  */
12685             bfd_put_32 (htab->elf.dynobj, 16, p);
12686             p += 4;
12687             /* CIE pointer.  */
12688             val = p - htab->glink_eh_frame->contents;
12689             bfd_put_32 (htab->elf.dynobj, val, p);
12690             p += 4;
12691             /* Offset to stub section.  */
12692             val = (stub_sec->output_section->vma
12693                    + stub_sec->output_offset);
12694             val -= (htab->glink_eh_frame->output_section->vma
12695                     + htab->glink_eh_frame->output_offset);
12696             val -= p - htab->glink_eh_frame->contents;
12697             if (val + 0x80000000 > 0xffffffff)
12698               {
12699                 info->callbacks->einfo
12700                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12701                    stub_sec->name);
12702                 return FALSE;
12703               }
12704             bfd_put_32 (htab->elf.dynobj, val, p);
12705             p += 4;
12706             /* stub section size.  */
12707             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12708             p += 4;
12709             /* Augmentation.  */
12710             p += 1;
12711             /* Pad.  */
12712             p += 3;
12713           }
12714       if (htab->glink != NULL && htab->glink->size != 0)
12715         {
12716           last_fde = p;
12717           last_fde_len = 20;
12718           /* FDE length.  */
12719           bfd_put_32 (htab->elf.dynobj, 20, p);
12720           p += 4;
12721           /* CIE pointer.  */
12722           val = p - htab->glink_eh_frame->contents;
12723           bfd_put_32 (htab->elf.dynobj, val, p);
12724           p += 4;
12725           /* Offset to .glink.  */
12726           val = (htab->glink->output_section->vma
12727                  + htab->glink->output_offset
12728                  + 8);
12729           val -= (htab->glink_eh_frame->output_section->vma
12730                   + htab->glink_eh_frame->output_offset);
12731           val -= p - htab->glink_eh_frame->contents;
12732           if (val + 0x80000000 > 0xffffffff)
12733             {
12734               info->callbacks->einfo
12735                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12736                  htab->glink->name);
12737               return FALSE;
12738             }
12739           bfd_put_32 (htab->elf.dynobj, val, p);
12740           p += 4;
12741           /* .glink size.  */
12742           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12743           p += 4;
12744           /* Augmentation.  */
12745           p += 1;
12746
12747           *p++ = DW_CFA_advance_loc + 1;
12748           *p++ = DW_CFA_register;
12749           *p++ = 65;
12750           *p++ = 12;
12751           *p++ = DW_CFA_advance_loc + 4;
12752           *p++ = DW_CFA_restore_extended;
12753           *p++ = 65;
12754         }
12755       /* Subsume any padding into the last FDE if user .eh_frame
12756          sections are aligned more than glink_eh_frame.  Otherwise any
12757          zero padding will be seen as a terminator.  */
12758       size = p - htab->glink_eh_frame->contents;
12759       align = 1;
12760       align <<= htab->glink_eh_frame->output_section->alignment_power;
12761       align -= 1;
12762       pad = ((size + align) & ~align) - size;
12763       htab->glink_eh_frame->size = size + pad;
12764       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12765     }
12766
12767   /* Build the stubs as directed by the stub hash table.  */
12768   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12769
12770   if (htab->relbrlt != NULL)
12771     htab->relbrlt->reloc_count = 0;
12772
12773   if (htab->params->plt_stub_align != 0)
12774     for (stub_sec = htab->params->stub_bfd->sections;
12775          stub_sec != NULL;
12776          stub_sec = stub_sec->next)
12777       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12778         stub_sec->size = ((stub_sec->size
12779                            + (1 << htab->params->plt_stub_align) - 1)
12780                           & (-1 << htab->params->plt_stub_align));
12781
12782   for (stub_sec = htab->params->stub_bfd->sections;
12783        stub_sec != NULL;
12784        stub_sec = stub_sec->next)
12785     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12786       {
12787         stub_sec_count += 1;
12788         if (stub_sec->rawsize != stub_sec->size)
12789           break;
12790       }
12791
12792   if (stub_sec != NULL
12793       || (htab->glink_eh_frame != NULL
12794           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12795     {
12796       htab->stub_error = TRUE;
12797       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12798     }
12799
12800   if (htab->stub_error)
12801     return FALSE;
12802
12803   if (stats != NULL)
12804     {
12805       *stats = bfd_malloc (500);
12806       if (*stats == NULL)
12807         return FALSE;
12808
12809       sprintf (*stats, _("linker stubs in %u group%s\n"
12810                          "  branch       %lu\n"
12811                          "  toc adjust   %lu\n"
12812                          "  long branch  %lu\n"
12813                          "  long toc adj %lu\n"
12814                          "  plt call     %lu\n"
12815                          "  plt call toc %lu"),
12816                stub_sec_count,
12817                stub_sec_count == 1 ? "" : "s",
12818                htab->stub_count[ppc_stub_long_branch - 1],
12819                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12820                htab->stub_count[ppc_stub_plt_branch - 1],
12821                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12822                htab->stub_count[ppc_stub_plt_call - 1],
12823                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12824     }
12825   return TRUE;
12826 }
12827
12828 /* This function undoes the changes made by add_symbol_adjust.  */
12829
12830 static bfd_boolean
12831 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12832 {
12833   struct ppc_link_hash_entry *eh;
12834
12835   if (h->root.type == bfd_link_hash_indirect)
12836     return TRUE;
12837
12838   eh = (struct ppc_link_hash_entry *) h;
12839   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12840     return TRUE;
12841
12842   eh->elf.root.type = bfd_link_hash_undefined;
12843   return TRUE;
12844 }
12845
12846 void
12847 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12848 {
12849   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12850
12851   if (htab != NULL)
12852     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12853 }
12854
12855 /* What to do when ld finds relocations against symbols defined in
12856    discarded sections.  */
12857
12858 static unsigned int
12859 ppc64_elf_action_discarded (asection *sec)
12860 {
12861   if (strcmp (".opd", sec->name) == 0)
12862     return 0;
12863
12864   if (strcmp (".toc", sec->name) == 0)
12865     return 0;
12866
12867   if (strcmp (".toc1", sec->name) == 0)
12868     return 0;
12869
12870   return _bfd_elf_default_action_discarded (sec);
12871 }
12872
12873 /* The RELOCATE_SECTION function is called by the ELF backend linker
12874    to handle the relocations for a section.
12875
12876    The relocs are always passed as Rela structures; if the section
12877    actually uses Rel structures, the r_addend field will always be
12878    zero.
12879
12880    This function is responsible for adjust the section contents as
12881    necessary, and (if using Rela relocs and generating a
12882    relocatable output file) adjusting the reloc addend as
12883    necessary.
12884
12885    This function does not have to worry about setting the reloc
12886    address or the reloc symbol index.
12887
12888    LOCAL_SYMS is a pointer to the swapped in local symbols.
12889
12890    LOCAL_SECTIONS is an array giving the section in the input file
12891    corresponding to the st_shndx field of each local symbol.
12892
12893    The global hash table entry for the global symbols can be found
12894    via elf_sym_hashes (input_bfd).
12895
12896    When generating relocatable output, this function must handle
12897    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12898    going to be the section symbol corresponding to the output
12899    section, which means that the addend must be adjusted
12900    accordingly.  */
12901
12902 static bfd_boolean
12903 ppc64_elf_relocate_section (bfd *output_bfd,
12904                             struct bfd_link_info *info,
12905                             bfd *input_bfd,
12906                             asection *input_section,
12907                             bfd_byte *contents,
12908                             Elf_Internal_Rela *relocs,
12909                             Elf_Internal_Sym *local_syms,
12910                             asection **local_sections)
12911 {
12912   struct ppc_link_hash_table *htab;
12913   Elf_Internal_Shdr *symtab_hdr;
12914   struct elf_link_hash_entry **sym_hashes;
12915   Elf_Internal_Rela *rel;
12916   Elf_Internal_Rela *relend;
12917   Elf_Internal_Rela outrel;
12918   bfd_byte *loc;
12919   struct got_entry **local_got_ents;
12920   bfd_vma TOCstart;
12921   bfd_boolean ret = TRUE;
12922   bfd_boolean is_opd;
12923   /* Assume 'at' branch hints.  */
12924   bfd_boolean is_isa_v2 = TRUE;
12925   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12926
12927   /* Initialize howto table if needed.  */
12928   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12929     ppc_howto_init ();
12930
12931   htab = ppc_hash_table (info);
12932   if (htab == NULL)
12933     return FALSE;
12934
12935   /* Don't relocate stub sections.  */
12936   if (input_section->owner == htab->params->stub_bfd)
12937     return TRUE;
12938
12939   BFD_ASSERT (is_ppc64_elf (input_bfd));
12940
12941   local_got_ents = elf_local_got_ents (input_bfd);
12942   TOCstart = elf_gp (output_bfd);
12943   symtab_hdr = &elf_symtab_hdr (input_bfd);
12944   sym_hashes = elf_sym_hashes (input_bfd);
12945   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12946
12947   rel = relocs;
12948   relend = relocs + input_section->reloc_count;
12949   for (; rel < relend; rel++)
12950     {
12951       enum elf_ppc64_reloc_type r_type;
12952       bfd_vma addend;
12953       bfd_reloc_status_type r;
12954       Elf_Internal_Sym *sym;
12955       asection *sec;
12956       struct elf_link_hash_entry *h_elf;
12957       struct ppc_link_hash_entry *h;
12958       struct ppc_link_hash_entry *fdh;
12959       const char *sym_name;
12960       unsigned long r_symndx, toc_symndx;
12961       bfd_vma toc_addend;
12962       unsigned char tls_mask, tls_gd, tls_type;
12963       unsigned char sym_type;
12964       bfd_vma relocation;
12965       bfd_boolean unresolved_reloc;
12966       bfd_boolean warned;
12967       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12968       unsigned int insn;
12969       unsigned int mask;
12970       struct ppc_stub_hash_entry *stub_entry;
12971       bfd_vma max_br_offset;
12972       bfd_vma from;
12973       const Elf_Internal_Rela orig_rel = *rel;
12974       reloc_howto_type *howto;
12975       struct reloc_howto_struct alt_howto;
12976
12977       r_type = ELF64_R_TYPE (rel->r_info);
12978       r_symndx = ELF64_R_SYM (rel->r_info);
12979
12980       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12981          symbol of the previous ADDR64 reloc.  The symbol gives us the
12982          proper TOC base to use.  */
12983       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12984           && rel != relocs
12985           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12986           && is_opd)
12987         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12988
12989       sym = NULL;
12990       sec = NULL;
12991       h_elf = NULL;
12992       sym_name = NULL;
12993       unresolved_reloc = FALSE;
12994       warned = FALSE;
12995
12996       if (r_symndx < symtab_hdr->sh_info)
12997         {
12998           /* It's a local symbol.  */
12999           struct _opd_sec_data *opd;
13000
13001           sym = local_syms + r_symndx;
13002           sec = local_sections[r_symndx];
13003           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13004           sym_type = ELF64_ST_TYPE (sym->st_info);
13005           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13006           opd = get_opd_info (sec);
13007           if (opd != NULL && opd->adjust != NULL)
13008             {
13009               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13010               if (adjust == -1)
13011                 relocation = 0;
13012               else
13013                 {
13014                   /* If this is a relocation against the opd section sym
13015                      and we have edited .opd, adjust the reloc addend so
13016                      that ld -r and ld --emit-relocs output is correct.
13017                      If it is a reloc against some other .opd symbol,
13018                      then the symbol value will be adjusted later.  */
13019                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13020                     rel->r_addend += adjust;
13021                   else
13022                     relocation += adjust;
13023                 }
13024             }
13025         }
13026       else
13027         {
13028           bfd_boolean ignored;
13029
13030           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13031                                    r_symndx, symtab_hdr, sym_hashes,
13032                                    h_elf, sec, relocation,
13033                                    unresolved_reloc, warned, ignored);
13034           sym_name = h_elf->root.root.string;
13035           sym_type = h_elf->type;
13036           if (sec != NULL
13037               && sec->owner == output_bfd
13038               && strcmp (sec->name, ".opd") == 0)
13039             {
13040               /* This is a symbol defined in a linker script.  All
13041                  such are defined in output sections, even those
13042                  defined by simple assignment from a symbol defined in
13043                  an input section.  Transfer the symbol to an
13044                  appropriate input .opd section, so that a branch to
13045                  this symbol will be mapped to the location specified
13046                  by the opd entry.  */
13047               struct bfd_link_order *lo;
13048               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13049                 if (lo->type == bfd_indirect_link_order)
13050                   {
13051                     asection *isec = lo->u.indirect.section;
13052                     if (h_elf->root.u.def.value >= isec->output_offset
13053                         && h_elf->root.u.def.value < (isec->output_offset
13054                                                       + isec->size))
13055                       {
13056                         h_elf->root.u.def.value -= isec->output_offset;
13057                         h_elf->root.u.def.section = isec;
13058                         sec = isec;
13059                         break;
13060                       }
13061                   }
13062             }
13063         }
13064       h = (struct ppc_link_hash_entry *) h_elf;
13065
13066       if (sec != NULL && discarded_section (sec))
13067         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13068                                          rel, 1, relend,
13069                                          ppc64_elf_howto_table[r_type], 0,
13070                                          contents);
13071
13072       if (info->relocatable)
13073         continue;
13074
13075       if (h != NULL && &h->elf == htab->elf.hgot)
13076         {
13077           relocation = (TOCstart
13078                         + htab->stub_group[input_section->id].toc_off);
13079           sec = bfd_abs_section_ptr;
13080           unresolved_reloc = FALSE;
13081         }
13082
13083       /* TLS optimizations.  Replace instruction sequences and relocs
13084          based on information we collected in tls_optimize.  We edit
13085          RELOCS so that --emit-relocs will output something sensible
13086          for the final instruction stream.  */
13087       tls_mask = 0;
13088       tls_gd = 0;
13089       toc_symndx = 0;
13090       if (h != NULL)
13091         tls_mask = h->tls_mask;
13092       else if (local_got_ents != NULL)
13093         {
13094           struct plt_entry **local_plt = (struct plt_entry **)
13095             (local_got_ents + symtab_hdr->sh_info);
13096           unsigned char *lgot_masks = (unsigned char *)
13097             (local_plt + symtab_hdr->sh_info);
13098           tls_mask = lgot_masks[r_symndx];
13099         }
13100       if (tls_mask == 0
13101           && (r_type == R_PPC64_TLS
13102               || r_type == R_PPC64_TLSGD
13103               || r_type == R_PPC64_TLSLD))
13104         {
13105           /* Check for toc tls entries.  */
13106           unsigned char *toc_tls;
13107
13108           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13109                              &local_syms, rel, input_bfd))
13110             return FALSE;
13111
13112           if (toc_tls)
13113             tls_mask = *toc_tls;
13114         }
13115
13116       /* Check that tls relocs are used with tls syms, and non-tls
13117          relocs are used with non-tls syms.  */
13118       if (r_symndx != STN_UNDEF
13119           && r_type != R_PPC64_NONE
13120           && (h == NULL
13121               || h->elf.root.type == bfd_link_hash_defined
13122               || h->elf.root.type == bfd_link_hash_defweak)
13123           && (IS_PPC64_TLS_RELOC (r_type)
13124               != (sym_type == STT_TLS
13125                   || (sym_type == STT_SECTION
13126                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13127         {
13128           if (tls_mask != 0
13129               && (r_type == R_PPC64_TLS
13130                   || r_type == R_PPC64_TLSGD
13131                   || r_type == R_PPC64_TLSLD))
13132             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13133             ;
13134           else
13135             info->callbacks->einfo
13136               (!IS_PPC64_TLS_RELOC (r_type)
13137                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13138                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13139                input_bfd, input_section, rel->r_offset,
13140                ppc64_elf_howto_table[r_type]->name,
13141                sym_name);
13142         }
13143
13144       /* Ensure reloc mapping code below stays sane.  */
13145       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13146           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13147           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13148           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13149           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13150           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13151           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13152           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13153           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13154           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13155         abort ();
13156
13157       switch (r_type)
13158         {
13159         default:
13160           break;
13161
13162         case R_PPC64_LO_DS_OPT:
13163           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13164           if ((insn & (0x3f << 26)) != 58u << 26)
13165             abort ();
13166           insn += (14u << 26) - (58u << 26);
13167           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13168           r_type = R_PPC64_TOC16_LO;
13169           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13170           break;
13171
13172         case R_PPC64_TOC16:
13173         case R_PPC64_TOC16_LO:
13174         case R_PPC64_TOC16_DS:
13175         case R_PPC64_TOC16_LO_DS:
13176           {
13177             /* Check for toc tls entries.  */
13178             unsigned char *toc_tls;
13179             int retval;
13180
13181             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13182                                    &local_syms, rel, input_bfd);
13183             if (retval == 0)
13184               return FALSE;
13185
13186             if (toc_tls)
13187               {
13188                 tls_mask = *toc_tls;
13189                 if (r_type == R_PPC64_TOC16_DS
13190                     || r_type == R_PPC64_TOC16_LO_DS)
13191                   {
13192                     if (tls_mask != 0
13193                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13194                       goto toctprel;
13195                   }
13196                 else
13197                   {
13198                     /* If we found a GD reloc pair, then we might be
13199                        doing a GD->IE transition.  */
13200                     if (retval == 2)
13201                       {
13202                         tls_gd = TLS_TPRELGD;
13203                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13204                           goto tls_ldgd_opt;
13205                       }
13206                     else if (retval == 3)
13207                       {
13208                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13209                           goto tls_ldgd_opt;
13210                       }
13211                   }
13212               }
13213           }
13214           break;
13215
13216         case R_PPC64_GOT_TPREL16_HI:
13217         case R_PPC64_GOT_TPREL16_HA:
13218           if (tls_mask != 0
13219               && (tls_mask & TLS_TPREL) == 0)
13220             {
13221               rel->r_offset -= d_offset;
13222               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13223               r_type = R_PPC64_NONE;
13224               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13225             }
13226           break;
13227
13228         case R_PPC64_GOT_TPREL16_DS:
13229         case R_PPC64_GOT_TPREL16_LO_DS:
13230           if (tls_mask != 0
13231               && (tls_mask & TLS_TPREL) == 0)
13232             {
13233             toctprel:
13234               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13235               insn &= 31 << 21;
13236               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13237               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13238               r_type = R_PPC64_TPREL16_HA;
13239               if (toc_symndx != 0)
13240                 {
13241                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13242                   rel->r_addend = toc_addend;
13243                   /* We changed the symbol.  Start over in order to
13244                      get h, sym, sec etc. right.  */
13245                   rel--;
13246                   continue;
13247                 }
13248               else
13249                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13250             }
13251           break;
13252
13253         case R_PPC64_TLS:
13254           if (tls_mask != 0
13255               && (tls_mask & TLS_TPREL) == 0)
13256             {
13257               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13258               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13259               if (insn == 0)
13260                 abort ();
13261               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13262               /* Was PPC64_TLS which sits on insn boundary, now
13263                  PPC64_TPREL16_LO which is at low-order half-word.  */
13264               rel->r_offset += d_offset;
13265               r_type = R_PPC64_TPREL16_LO;
13266               if (toc_symndx != 0)
13267                 {
13268                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13269                   rel->r_addend = toc_addend;
13270                   /* We changed the symbol.  Start over in order to
13271                      get h, sym, sec etc. right.  */
13272                   rel--;
13273                   continue;
13274                 }
13275               else
13276                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13277             }
13278           break;
13279
13280         case R_PPC64_GOT_TLSGD16_HI:
13281         case R_PPC64_GOT_TLSGD16_HA:
13282           tls_gd = TLS_TPRELGD;
13283           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13284             goto tls_gdld_hi;
13285           break;
13286
13287         case R_PPC64_GOT_TLSLD16_HI:
13288         case R_PPC64_GOT_TLSLD16_HA:
13289           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13290             {
13291             tls_gdld_hi:
13292               if ((tls_mask & tls_gd) != 0)
13293                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13294                           + R_PPC64_GOT_TPREL16_DS);
13295               else
13296                 {
13297                   rel->r_offset -= d_offset;
13298                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13299                   r_type = R_PPC64_NONE;
13300                 }
13301               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13302             }
13303           break;
13304
13305         case R_PPC64_GOT_TLSGD16:
13306         case R_PPC64_GOT_TLSGD16_LO:
13307           tls_gd = TLS_TPRELGD;
13308           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13309             goto tls_ldgd_opt;
13310           break;
13311
13312         case R_PPC64_GOT_TLSLD16:
13313         case R_PPC64_GOT_TLSLD16_LO:
13314           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13315             {
13316               unsigned int insn1, insn2, insn3;
13317               bfd_vma offset;
13318
13319             tls_ldgd_opt:
13320               offset = (bfd_vma) -1;
13321               /* If not using the newer R_PPC64_TLSGD/LD to mark
13322                  __tls_get_addr calls, we must trust that the call
13323                  stays with its arg setup insns, ie. that the next
13324                  reloc is the __tls_get_addr call associated with
13325                  the current reloc.  Edit both insns.  */
13326               if (input_section->has_tls_get_addr_call
13327                   && rel + 1 < relend
13328                   && branch_reloc_hash_match (input_bfd, rel + 1,
13329                                               htab->tls_get_addr,
13330                                               htab->tls_get_addr_fd))
13331                 offset = rel[1].r_offset;
13332               if ((tls_mask & tls_gd) != 0)
13333                 {
13334                   /* IE */
13335                   insn1 = bfd_get_32 (output_bfd,
13336                                       contents + rel->r_offset - d_offset);
13337                   insn1 &= (1 << 26) - (1 << 2);
13338                   insn1 |= 58 << 26;    /* ld */
13339                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13340                   if (offset != (bfd_vma) -1)
13341                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13342                   if ((tls_mask & TLS_EXPLICIT) == 0)
13343                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13344                               + R_PPC64_GOT_TPREL16_DS);
13345                   else
13346                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13347                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13348                 }
13349               else
13350                 {
13351                   /* LE */
13352                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13353                   insn2 = 0x38630000;   /* addi 3,3,0 */
13354                   if (tls_gd == 0)
13355                     {
13356                       /* Was an LD reloc.  */
13357                       if (toc_symndx)
13358                         sec = local_sections[toc_symndx];
13359                       for (r_symndx = 0;
13360                            r_symndx < symtab_hdr->sh_info;
13361                            r_symndx++)
13362                         if (local_sections[r_symndx] == sec)
13363                           break;
13364                       if (r_symndx >= symtab_hdr->sh_info)
13365                         r_symndx = STN_UNDEF;
13366                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13367                       if (r_symndx != STN_UNDEF)
13368                         rel->r_addend -= (local_syms[r_symndx].st_value
13369                                           + sec->output_offset
13370                                           + sec->output_section->vma);
13371                     }
13372                   else if (toc_symndx != 0)
13373                     {
13374                       r_symndx = toc_symndx;
13375                       rel->r_addend = toc_addend;
13376                     }
13377                   r_type = R_PPC64_TPREL16_HA;
13378                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379                   if (offset != (bfd_vma) -1)
13380                     {
13381                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13382                                                     R_PPC64_TPREL16_LO);
13383                       rel[1].r_offset = offset + d_offset;
13384                       rel[1].r_addend = rel->r_addend;
13385                     }
13386                 }
13387               bfd_put_32 (output_bfd, insn1,
13388                           contents + rel->r_offset - d_offset);
13389               if (offset != (bfd_vma) -1)
13390                 {
13391                   insn3 = bfd_get_32 (output_bfd,
13392                                       contents + offset + 4);
13393                   if (insn3 == NOP
13394                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13395                     {
13396                       rel[1].r_offset += 4;
13397                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13398                       insn2 = NOP;
13399                     }
13400                   bfd_put_32 (output_bfd, insn2, contents + offset);
13401                 }
13402               if ((tls_mask & tls_gd) == 0
13403                   && (tls_gd == 0 || toc_symndx != 0))
13404                 {
13405                   /* We changed the symbol.  Start over in order
13406                      to get h, sym, sec etc. right.  */
13407                   rel--;
13408                   continue;
13409                 }
13410             }
13411           break;
13412
13413         case R_PPC64_TLSGD:
13414           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13415             {
13416               unsigned int insn2, insn3;
13417               bfd_vma offset = rel->r_offset;
13418
13419               if ((tls_mask & TLS_TPRELGD) != 0)
13420                 {
13421                   /* IE */
13422                   r_type = R_PPC64_NONE;
13423                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13424                 }
13425               else
13426                 {
13427                   /* LE */
13428                   if (toc_symndx != 0)
13429                     {
13430                       r_symndx = toc_symndx;
13431                       rel->r_addend = toc_addend;
13432                     }
13433                   r_type = R_PPC64_TPREL16_LO;
13434                   rel->r_offset = offset + d_offset;
13435                   insn2 = 0x38630000;   /* addi 3,3,0 */
13436                 }
13437               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13438               /* Zap the reloc on the _tls_get_addr call too.  */
13439               BFD_ASSERT (offset == rel[1].r_offset);
13440               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13441               insn3 = bfd_get_32 (output_bfd,
13442                                   contents + offset + 4);
13443               if (insn3 == NOP
13444                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13445                 {
13446                   rel->r_offset += 4;
13447                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13448                   insn2 = NOP;
13449                 }
13450               bfd_put_32 (output_bfd, insn2, contents + offset);
13451               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13452                 {
13453                   rel--;
13454                   continue;
13455                 }
13456             }
13457           break;
13458
13459         case R_PPC64_TLSLD:
13460           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13461             {
13462               unsigned int insn2, insn3;
13463               bfd_vma offset = rel->r_offset;
13464
13465               if (toc_symndx)
13466                 sec = local_sections[toc_symndx];
13467               for (r_symndx = 0;
13468                    r_symndx < symtab_hdr->sh_info;
13469                    r_symndx++)
13470                 if (local_sections[r_symndx] == sec)
13471                   break;
13472               if (r_symndx >= symtab_hdr->sh_info)
13473                 r_symndx = STN_UNDEF;
13474               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13475               if (r_symndx != STN_UNDEF)
13476                 rel->r_addend -= (local_syms[r_symndx].st_value
13477                                   + sec->output_offset
13478                                   + sec->output_section->vma);
13479
13480               r_type = R_PPC64_TPREL16_LO;
13481               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13482               rel->r_offset = offset + d_offset;
13483               /* Zap the reloc on the _tls_get_addr call too.  */
13484               BFD_ASSERT (offset == rel[1].r_offset);
13485               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13486               insn2 = 0x38630000;       /* addi 3,3,0 */
13487               insn3 = bfd_get_32 (output_bfd,
13488                                   contents + offset + 4);
13489               if (insn3 == NOP
13490                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13491                 {
13492                   rel->r_offset += 4;
13493                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13494                   insn2 = NOP;
13495                 }
13496               bfd_put_32 (output_bfd, insn2, contents + offset);
13497               rel--;
13498               continue;
13499             }
13500           break;
13501
13502         case R_PPC64_DTPMOD64:
13503           if (rel + 1 < relend
13504               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13505               && rel[1].r_offset == rel->r_offset + 8)
13506             {
13507               if ((tls_mask & TLS_GD) == 0)
13508                 {
13509                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13510                   if ((tls_mask & TLS_TPRELGD) != 0)
13511                     r_type = R_PPC64_TPREL64;
13512                   else
13513                     {
13514                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13515                       r_type = R_PPC64_NONE;
13516                     }
13517                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13518                 }
13519             }
13520           else
13521             {
13522               if ((tls_mask & TLS_LD) == 0)
13523                 {
13524                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13525                   r_type = R_PPC64_NONE;
13526                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13527                 }
13528             }
13529           break;
13530
13531         case R_PPC64_TPREL64:
13532           if ((tls_mask & TLS_TPREL) == 0)
13533             {
13534               r_type = R_PPC64_NONE;
13535               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13536             }
13537           break;
13538
13539         case R_PPC64_REL16_HA:
13540           /* If we are generating a non-PIC executable, edit
13541              .  0:      addis 2,12,.TOC.-0b@ha
13542              .          addi 2,2,.TOC.-0b@l
13543              used by ELFv2 global entry points to set up r2, to
13544              .          lis 2,.TOC.@ha
13545              .          addi 2,2,.TOC.@l
13546              if .TOC. is in range.  */
13547           if (!info->shared
13548               && h != NULL && &h->elf == htab->elf.hgot
13549               && rel + 1 < relend
13550               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13551               && rel[1].r_offset == rel->r_offset + 4
13552               && rel[1].r_addend == rel->r_addend + 4
13553               && relocation + 0x80008000 <= 0xffffffff)
13554             {
13555               unsigned int insn1, insn2;
13556               bfd_vma offset = rel->r_offset - d_offset;
13557               insn1 = bfd_get_32 (output_bfd, contents + offset);
13558               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13559               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13560                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13561                 {
13562                   r_type = R_PPC64_ADDR16_HA;
13563                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13564                   rel->r_addend -= d_offset;
13565                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13566                   rel[1].r_addend -= d_offset + 4;
13567                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13568                 }
13569             }
13570           break;
13571         }
13572
13573       /* Handle other relocations that tweak non-addend part of insn.  */
13574       insn = 0;
13575       max_br_offset = 1 << 25;
13576       addend = rel->r_addend;
13577       reloc_dest = DEST_NORMAL;
13578       switch (r_type)
13579         {
13580         default:
13581           break;
13582
13583         case R_PPC64_TOCSAVE:
13584           if (relocation + addend == (rel->r_offset
13585                                       + input_section->output_offset
13586                                       + input_section->output_section->vma)
13587               && tocsave_find (htab, NO_INSERT,
13588                                &local_syms, rel, input_bfd))
13589             {
13590               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13591               if (insn == NOP
13592                   || insn == CROR_151515 || insn == CROR_313131)
13593                 bfd_put_32 (input_bfd,
13594                             STD_R2_0R1 + STK_TOC (htab),
13595                             contents + rel->r_offset);
13596             }
13597           break;
13598
13599           /* Branch taken prediction relocations.  */
13600         case R_PPC64_ADDR14_BRTAKEN:
13601         case R_PPC64_REL14_BRTAKEN:
13602           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13603           /* Fall thru.  */
13604
13605           /* Branch not taken prediction relocations.  */
13606         case R_PPC64_ADDR14_BRNTAKEN:
13607         case R_PPC64_REL14_BRNTAKEN:
13608           insn |= bfd_get_32 (output_bfd,
13609                               contents + rel->r_offset) & ~(0x01 << 21);
13610           /* Fall thru.  */
13611
13612         case R_PPC64_REL14:
13613           max_br_offset = 1 << 15;
13614           /* Fall thru.  */
13615
13616         case R_PPC64_REL24:
13617           /* Calls to functions with a different TOC, such as calls to
13618              shared objects, need to alter the TOC pointer.  This is
13619              done using a linkage stub.  A REL24 branching to these
13620              linkage stubs needs to be followed by a nop, as the nop
13621              will be replaced with an instruction to restore the TOC
13622              base pointer.  */
13623           fdh = h;
13624           if (h != NULL
13625               && h->oh != NULL
13626               && h->oh->is_func_descriptor)
13627             fdh = ppc_follow_link (h->oh);
13628           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13629                                            htab);
13630           if (stub_entry != NULL
13631               && (stub_entry->stub_type == ppc_stub_plt_call
13632                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13633                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13634                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13635             {
13636               bfd_boolean can_plt_call = FALSE;
13637
13638               /* All of these stubs will modify r2, so there must be a
13639                  branch and link followed by a nop.  The nop is
13640                  replaced by an insn to restore r2.  */
13641               if (rel->r_offset + 8 <= input_section->size)
13642                 {
13643                   unsigned long br;
13644
13645                   br = bfd_get_32 (input_bfd,
13646                                    contents + rel->r_offset);
13647                   if ((br & 1) != 0)
13648                     {
13649                       unsigned long nop;
13650
13651                       nop = bfd_get_32 (input_bfd,
13652                                         contents + rel->r_offset + 4);
13653                       if (nop == NOP
13654                           || nop == CROR_151515 || nop == CROR_313131)
13655                         {
13656                           if (h != NULL
13657                               && (h == htab->tls_get_addr_fd
13658                                   || h == htab->tls_get_addr)
13659                               && !htab->params->no_tls_get_addr_opt)
13660                             {
13661                               /* Special stub used, leave nop alone.  */
13662                             }
13663                           else
13664                             bfd_put_32 (input_bfd,
13665                                         LD_R2_0R1 + STK_TOC (htab),
13666                                         contents + rel->r_offset + 4);
13667                           can_plt_call = TRUE;
13668                         }
13669                     }
13670                 }
13671
13672               if (!can_plt_call && h != NULL)
13673                 {
13674                   const char *name = h->elf.root.root.string;
13675
13676                   if (*name == '.')
13677                     ++name;
13678
13679                   if (strncmp (name, "__libc_start_main", 17) == 0
13680                       && (name[17] == 0 || name[17] == '@'))
13681                     {
13682                       /* Allow crt1 branch to go via a toc adjusting
13683                          stub.  Other calls that never return could do
13684                          the same, if we could detect such.  */
13685                       can_plt_call = TRUE;
13686                     }
13687                 }
13688
13689               if (!can_plt_call)
13690                 {
13691                   /* g++ as of 20130507 emits self-calls without a
13692                      following nop.  This is arguably wrong since we
13693                      have conflicting information.  On the one hand a
13694                      global symbol and on the other a local call
13695                      sequence, but don't error for this special case.
13696                      It isn't possible to cheaply verify we have
13697                      exactly such a call.  Allow all calls to the same
13698                      section.  */
13699                   asection *code_sec = sec;
13700
13701                   if (get_opd_info (sec) != NULL)
13702                     {
13703                       bfd_vma off = (relocation + addend
13704                                      - sec->output_section->vma
13705                                      - sec->output_offset);
13706
13707                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13708                     }
13709                   if (code_sec == input_section)
13710                     can_plt_call = TRUE;
13711                 }
13712
13713               if (!can_plt_call)
13714                 {
13715                   info->callbacks->einfo
13716                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13717                        "recompile with -fPIC\n"),
13718                      input_bfd, input_section, rel->r_offset, sym_name);
13719
13720                   bfd_set_error (bfd_error_bad_value);
13721                   ret = FALSE;
13722                 }
13723
13724               if (can_plt_call
13725                   && (stub_entry->stub_type == ppc_stub_plt_call
13726                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13727                 unresolved_reloc = FALSE;
13728             }
13729
13730           if ((stub_entry == NULL
13731                || stub_entry->stub_type == ppc_stub_long_branch
13732                || stub_entry->stub_type == ppc_stub_plt_branch)
13733               && get_opd_info (sec) != NULL)
13734             {
13735               /* The branch destination is the value of the opd entry. */
13736               bfd_vma off = (relocation + addend
13737                              - sec->output_section->vma
13738                              - sec->output_offset);
13739               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13740               if (dest != (bfd_vma) -1)
13741                 {
13742                   relocation = dest;
13743                   addend = 0;
13744                   reloc_dest = DEST_OPD;
13745                 }
13746             }
13747
13748           /* If the branch is out of reach we ought to have a long
13749              branch stub.  */
13750           from = (rel->r_offset
13751                   + input_section->output_offset
13752                   + input_section->output_section->vma);
13753
13754           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13755                                                   ? fdh->elf.other
13756                                                   : sym->st_other);
13757
13758           if (stub_entry != NULL
13759               && (stub_entry->stub_type == ppc_stub_long_branch
13760                   || stub_entry->stub_type == ppc_stub_plt_branch)
13761               && (r_type == R_PPC64_ADDR14_BRTAKEN
13762                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13763                   || (relocation + addend - from + max_br_offset
13764                       < 2 * max_br_offset)))
13765             /* Don't use the stub if this branch is in range.  */
13766             stub_entry = NULL;
13767
13768           if (stub_entry != NULL)
13769             {
13770               /* Munge up the value and addend so that we call the stub
13771                  rather than the procedure directly.  */
13772               relocation = (stub_entry->stub_offset
13773                             + stub_entry->stub_sec->output_offset
13774                             + stub_entry->stub_sec->output_section->vma);
13775               addend = 0;
13776               reloc_dest = DEST_STUB;
13777
13778               if ((stub_entry->stub_type == ppc_stub_plt_call
13779                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13780                   && (ALWAYS_EMIT_R2SAVE
13781                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13782                   && rel + 1 < relend
13783                   && rel[1].r_offset == rel->r_offset + 4
13784                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13785                 relocation += 4;
13786             }
13787
13788           if (insn != 0)
13789             {
13790               if (is_isa_v2)
13791                 {
13792                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13793                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13794                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13795                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13796                     insn |= 0x02 << 21;
13797                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13798                     insn |= 0x08 << 21;
13799                   else
13800                     break;
13801                 }
13802               else
13803                 {
13804                   /* Invert 'y' bit if not the default.  */
13805                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13806                     insn ^= 0x01 << 21;
13807                 }
13808
13809               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13810             }
13811
13812           /* NOP out calls to undefined weak functions.
13813              We can thus call a weak function without first
13814              checking whether the function is defined.  */
13815           else if (h != NULL
13816                    && h->elf.root.type == bfd_link_hash_undefweak
13817                    && h->elf.dynindx == -1
13818                    && r_type == R_PPC64_REL24
13819                    && relocation == 0
13820                    && addend == 0)
13821             {
13822               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13823               continue;
13824             }
13825           break;
13826         }
13827
13828       /* Set `addend'.  */
13829       tls_type = 0;
13830       switch (r_type)
13831         {
13832         default:
13833           info->callbacks->einfo
13834             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13835              input_bfd, (int) r_type, sym_name);
13836
13837           bfd_set_error (bfd_error_bad_value);
13838           ret = FALSE;
13839           continue;
13840
13841         case R_PPC64_NONE:
13842         case R_PPC64_TLS:
13843         case R_PPC64_TLSGD:
13844         case R_PPC64_TLSLD:
13845         case R_PPC64_TOCSAVE:
13846         case R_PPC64_GNU_VTINHERIT:
13847         case R_PPC64_GNU_VTENTRY:
13848           continue;
13849
13850           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13851              address in the GOT as relocation value instead of the
13852              symbol's value itself.  Also, create a GOT entry for the
13853              symbol and put the symbol value there.  */
13854         case R_PPC64_GOT_TLSGD16:
13855         case R_PPC64_GOT_TLSGD16_LO:
13856         case R_PPC64_GOT_TLSGD16_HI:
13857         case R_PPC64_GOT_TLSGD16_HA:
13858           tls_type = TLS_TLS | TLS_GD;
13859           goto dogot;
13860
13861         case R_PPC64_GOT_TLSLD16:
13862         case R_PPC64_GOT_TLSLD16_LO:
13863         case R_PPC64_GOT_TLSLD16_HI:
13864         case R_PPC64_GOT_TLSLD16_HA:
13865           tls_type = TLS_TLS | TLS_LD;
13866           goto dogot;
13867
13868         case R_PPC64_GOT_TPREL16_DS:
13869         case R_PPC64_GOT_TPREL16_LO_DS:
13870         case R_PPC64_GOT_TPREL16_HI:
13871         case R_PPC64_GOT_TPREL16_HA:
13872           tls_type = TLS_TLS | TLS_TPREL;
13873           goto dogot;
13874
13875         case R_PPC64_GOT_DTPREL16_DS:
13876         case R_PPC64_GOT_DTPREL16_LO_DS:
13877         case R_PPC64_GOT_DTPREL16_HI:
13878         case R_PPC64_GOT_DTPREL16_HA:
13879           tls_type = TLS_TLS | TLS_DTPREL;
13880           goto dogot;
13881
13882         case R_PPC64_GOT16:
13883         case R_PPC64_GOT16_LO:
13884         case R_PPC64_GOT16_HI:
13885         case R_PPC64_GOT16_HA:
13886         case R_PPC64_GOT16_DS:
13887         case R_PPC64_GOT16_LO_DS:
13888         dogot:
13889           {
13890             /* Relocation is to the entry for this symbol in the global
13891                offset table.  */
13892             asection *got;
13893             bfd_vma *offp;
13894             bfd_vma off;
13895             unsigned long indx = 0;
13896             struct got_entry *ent;
13897
13898             if (tls_type == (TLS_TLS | TLS_LD)
13899                 && (h == NULL
13900                     || !h->elf.def_dynamic))
13901               ent = ppc64_tlsld_got (input_bfd);
13902             else
13903               {
13904
13905                 if (h != NULL)
13906                   {
13907                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13908                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13909                                                           &h->elf)
13910                         || (info->shared
13911                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13912                       /* This is actually a static link, or it is a
13913                          -Bsymbolic link and the symbol is defined
13914                          locally, or the symbol was forced to be local
13915                          because of a version file.  */
13916                       ;
13917                     else
13918                       {
13919                         BFD_ASSERT (h->elf.dynindx != -1);
13920                         indx = h->elf.dynindx;
13921                         unresolved_reloc = FALSE;
13922                       }
13923                     ent = h->elf.got.glist;
13924                   }
13925                 else
13926                   {
13927                     if (local_got_ents == NULL)
13928                       abort ();
13929                     ent = local_got_ents[r_symndx];
13930                   }
13931
13932                 for (; ent != NULL; ent = ent->next)
13933                   if (ent->addend == orig_rel.r_addend
13934                       && ent->owner == input_bfd
13935                       && ent->tls_type == tls_type)
13936                     break;
13937               }
13938
13939             if (ent == NULL)
13940               abort ();
13941             if (ent->is_indirect)
13942               ent = ent->got.ent;
13943             offp = &ent->got.offset;
13944             got = ppc64_elf_tdata (ent->owner)->got;
13945             if (got == NULL)
13946               abort ();
13947
13948             /* The offset must always be a multiple of 8.  We use the
13949                least significant bit to record whether we have already
13950                processed this entry.  */
13951             off = *offp;
13952             if ((off & 1) != 0)
13953               off &= ~1;
13954             else
13955               {
13956                 /* Generate relocs for the dynamic linker, except in
13957                    the case of TLSLD where we'll use one entry per
13958                    module.  */
13959                 asection *relgot;
13960                 bfd_boolean ifunc;
13961
13962                 *offp = off | 1;
13963                 relgot = NULL;
13964                 ifunc = (h != NULL
13965                          ? h->elf.type == STT_GNU_IFUNC
13966                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13967                 if (ifunc)
13968                   relgot = htab->elf.irelplt;
13969                 else if ((info->shared || indx != 0)
13970                          && (h == NULL
13971                              || (tls_type == (TLS_TLS | TLS_LD)
13972                                  && !h->elf.def_dynamic)
13973                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13974                              || h->elf.root.type != bfd_link_hash_undefweak))
13975                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13976                 if (relgot != NULL)
13977                   {
13978                     outrel.r_offset = (got->output_section->vma
13979                                        + got->output_offset
13980                                        + off);
13981                     outrel.r_addend = addend;
13982                     if (tls_type & (TLS_LD | TLS_GD))
13983                       {
13984                         outrel.r_addend = 0;
13985                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13986                         if (tls_type == (TLS_TLS | TLS_GD))
13987                           {
13988                             loc = relgot->contents;
13989                             loc += (relgot->reloc_count++
13990                                     * sizeof (Elf64_External_Rela));
13991                             bfd_elf64_swap_reloca_out (output_bfd,
13992                                                        &outrel, loc);
13993                             outrel.r_offset += 8;
13994                             outrel.r_addend = addend;
13995                             outrel.r_info
13996                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13997                           }
13998                       }
13999                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14000                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14001                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14002                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14003                     else if (indx != 0)
14004                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14005                     else
14006                       {
14007                         if (ifunc)
14008                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14009                         else
14010                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14011
14012                         /* Write the .got section contents for the sake
14013                            of prelink.  */
14014                         loc = got->contents + off;
14015                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14016                                     loc);
14017                       }
14018
14019                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14020                       {
14021                         outrel.r_addend += relocation;
14022                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14023                           outrel.r_addend -= htab->elf.tls_sec->vma;
14024                       }
14025                     loc = relgot->contents;
14026                     loc += (relgot->reloc_count++
14027                             * sizeof (Elf64_External_Rela));
14028                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14029                   }
14030
14031                 /* Init the .got section contents here if we're not
14032                    emitting a reloc.  */
14033                 else
14034                   {
14035                     relocation += addend;
14036                     if (tls_type == (TLS_TLS | TLS_LD))
14037                       relocation = 1;
14038                     else if (tls_type != 0)
14039                       {
14040                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14041                         if (tls_type == (TLS_TLS | TLS_TPREL))
14042                           relocation += DTP_OFFSET - TP_OFFSET;
14043
14044                         if (tls_type == (TLS_TLS | TLS_GD))
14045                           {
14046                             bfd_put_64 (output_bfd, relocation,
14047                                         got->contents + off + 8);
14048                             relocation = 1;
14049                           }
14050                       }
14051
14052                     bfd_put_64 (output_bfd, relocation,
14053                                 got->contents + off);
14054                   }
14055               }
14056
14057             if (off >= (bfd_vma) -2)
14058               abort ();
14059
14060             relocation = got->output_section->vma + got->output_offset + off;
14061             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14062           }
14063           break;
14064
14065         case R_PPC64_PLT16_HA:
14066         case R_PPC64_PLT16_HI:
14067         case R_PPC64_PLT16_LO:
14068         case R_PPC64_PLT32:
14069         case R_PPC64_PLT64:
14070           /* Relocation is to the entry for this symbol in the
14071              procedure linkage table.  */
14072
14073           /* Resolve a PLT reloc against a local symbol directly,
14074              without using the procedure linkage table.  */
14075           if (h == NULL)
14076             break;
14077
14078           /* It's possible that we didn't make a PLT entry for this
14079              symbol.  This happens when statically linking PIC code,
14080              or when using -Bsymbolic.  Go find a match if there is a
14081              PLT entry.  */
14082           if (htab->elf.splt != NULL)
14083             {
14084               struct plt_entry *ent;
14085               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14086                 if (ent->plt.offset != (bfd_vma) -1
14087                     && ent->addend == orig_rel.r_addend)
14088                   {
14089                     relocation = (htab->elf.splt->output_section->vma
14090                                   + htab->elf.splt->output_offset
14091                                   + ent->plt.offset);
14092                     unresolved_reloc = FALSE;
14093                     break;
14094                   }
14095             }
14096           break;
14097
14098         case R_PPC64_TOC:
14099           /* Relocation value is TOC base.  */
14100           relocation = TOCstart;
14101           if (r_symndx == STN_UNDEF)
14102             relocation += htab->stub_group[input_section->id].toc_off;
14103           else if (unresolved_reloc)
14104             ;
14105           else if (sec != NULL && sec->id <= htab->top_id)
14106             relocation += htab->stub_group[sec->id].toc_off;
14107           else
14108             unresolved_reloc = TRUE;
14109           goto dodyn;
14110
14111           /* TOC16 relocs.  We want the offset relative to the TOC base,
14112              which is the address of the start of the TOC plus 0x8000.
14113              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14114              in this order.  */
14115         case R_PPC64_TOC16:
14116         case R_PPC64_TOC16_LO:
14117         case R_PPC64_TOC16_HI:
14118         case R_PPC64_TOC16_DS:
14119         case R_PPC64_TOC16_LO_DS:
14120         case R_PPC64_TOC16_HA:
14121           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14122           break;
14123
14124           /* Relocate against the beginning of the section.  */
14125         case R_PPC64_SECTOFF:
14126         case R_PPC64_SECTOFF_LO:
14127         case R_PPC64_SECTOFF_HI:
14128         case R_PPC64_SECTOFF_DS:
14129         case R_PPC64_SECTOFF_LO_DS:
14130         case R_PPC64_SECTOFF_HA:
14131           if (sec != NULL)
14132             addend -= sec->output_section->vma;
14133           break;
14134
14135         case R_PPC64_REL16:
14136         case R_PPC64_REL16_LO:
14137         case R_PPC64_REL16_HI:
14138         case R_PPC64_REL16_HA:
14139           break;
14140
14141         case R_PPC64_REL14:
14142         case R_PPC64_REL14_BRNTAKEN:
14143         case R_PPC64_REL14_BRTAKEN:
14144         case R_PPC64_REL24:
14145           break;
14146
14147         case R_PPC64_TPREL16:
14148         case R_PPC64_TPREL16_LO:
14149         case R_PPC64_TPREL16_HI:
14150         case R_PPC64_TPREL16_HA:
14151         case R_PPC64_TPREL16_DS:
14152         case R_PPC64_TPREL16_LO_DS:
14153         case R_PPC64_TPREL16_HIGH:
14154         case R_PPC64_TPREL16_HIGHA:
14155         case R_PPC64_TPREL16_HIGHER:
14156         case R_PPC64_TPREL16_HIGHERA:
14157         case R_PPC64_TPREL16_HIGHEST:
14158         case R_PPC64_TPREL16_HIGHESTA:
14159           if (h != NULL
14160               && h->elf.root.type == bfd_link_hash_undefweak
14161               && h->elf.dynindx == -1)
14162             {
14163               /* Make this relocation against an undefined weak symbol
14164                  resolve to zero.  This is really just a tweak, since
14165                  code using weak externs ought to check that they are
14166                  defined before using them.  */
14167               bfd_byte *p = contents + rel->r_offset - d_offset;
14168
14169               insn = bfd_get_32 (output_bfd, p);
14170               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14171               if (insn != 0)
14172                 bfd_put_32 (output_bfd, insn, p);
14173               break;
14174             }
14175           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14176           if (info->shared)
14177             /* The TPREL16 relocs shouldn't really be used in shared
14178                libs as they will result in DT_TEXTREL being set, but
14179                support them anyway.  */
14180             goto dodyn;
14181           break;
14182
14183         case R_PPC64_DTPREL16:
14184         case R_PPC64_DTPREL16_LO:
14185         case R_PPC64_DTPREL16_HI:
14186         case R_PPC64_DTPREL16_HA:
14187         case R_PPC64_DTPREL16_DS:
14188         case R_PPC64_DTPREL16_LO_DS:
14189         case R_PPC64_DTPREL16_HIGH:
14190         case R_PPC64_DTPREL16_HIGHA:
14191         case R_PPC64_DTPREL16_HIGHER:
14192         case R_PPC64_DTPREL16_HIGHERA:
14193         case R_PPC64_DTPREL16_HIGHEST:
14194         case R_PPC64_DTPREL16_HIGHESTA:
14195           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14196           break;
14197
14198         case R_PPC64_ADDR64_LOCAL:
14199           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14200                                               ? h->elf.other
14201                                               : sym->st_other);
14202           break;
14203
14204         case R_PPC64_DTPMOD64:
14205           relocation = 1;
14206           addend = 0;
14207           goto dodyn;
14208
14209         case R_PPC64_TPREL64:
14210           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14211           goto dodyn;
14212
14213         case R_PPC64_DTPREL64:
14214           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14215           /* Fall thru */
14216
14217           /* Relocations that may need to be propagated if this is a
14218              dynamic object.  */
14219         case R_PPC64_REL30:
14220         case R_PPC64_REL32:
14221         case R_PPC64_REL64:
14222         case R_PPC64_ADDR14:
14223         case R_PPC64_ADDR14_BRNTAKEN:
14224         case R_PPC64_ADDR14_BRTAKEN:
14225         case R_PPC64_ADDR16:
14226         case R_PPC64_ADDR16_DS:
14227         case R_PPC64_ADDR16_HA:
14228         case R_PPC64_ADDR16_HI:
14229         case R_PPC64_ADDR16_HIGH:
14230         case R_PPC64_ADDR16_HIGHA:
14231         case R_PPC64_ADDR16_HIGHER:
14232         case R_PPC64_ADDR16_HIGHERA:
14233         case R_PPC64_ADDR16_HIGHEST:
14234         case R_PPC64_ADDR16_HIGHESTA:
14235         case R_PPC64_ADDR16_LO:
14236         case R_PPC64_ADDR16_LO_DS:
14237         case R_PPC64_ADDR24:
14238         case R_PPC64_ADDR32:
14239         case R_PPC64_ADDR64:
14240         case R_PPC64_UADDR16:
14241         case R_PPC64_UADDR32:
14242         case R_PPC64_UADDR64:
14243         dodyn:
14244           if ((input_section->flags & SEC_ALLOC) == 0)
14245             break;
14246
14247           if (NO_OPD_RELOCS && is_opd)
14248             break;
14249
14250           if ((info->shared
14251                && (h == NULL
14252                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14253                    || h->elf.root.type != bfd_link_hash_undefweak)
14254                && (must_be_dyn_reloc (info, r_type)
14255                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14256               || (ELIMINATE_COPY_RELOCS
14257                   && !info->shared
14258                   && h != NULL
14259                   && h->elf.dynindx != -1
14260                   && !h->elf.non_got_ref
14261                   && !h->elf.def_regular)
14262               || (!info->shared
14263                   && (h != NULL
14264                       ? h->elf.type == STT_GNU_IFUNC
14265                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14266             {
14267               bfd_boolean skip, relocate;
14268               asection *sreloc;
14269               bfd_vma out_off;
14270
14271               /* When generating a dynamic object, these relocations
14272                  are copied into the output file to be resolved at run
14273                  time.  */
14274
14275               skip = FALSE;
14276               relocate = FALSE;
14277
14278               out_off = _bfd_elf_section_offset (output_bfd, info,
14279                                                  input_section, rel->r_offset);
14280               if (out_off == (bfd_vma) -1)
14281                 skip = TRUE;
14282               else if (out_off == (bfd_vma) -2)
14283                 skip = TRUE, relocate = TRUE;
14284               out_off += (input_section->output_section->vma
14285                           + input_section->output_offset);
14286               outrel.r_offset = out_off;
14287               outrel.r_addend = rel->r_addend;
14288
14289               /* Optimize unaligned reloc use.  */
14290               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14291                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14292                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14293               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14294                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14295                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14296               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14297                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14298                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14299
14300               if (skip)
14301                 memset (&outrel, 0, sizeof outrel);
14302               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14303                        && !is_opd
14304                        && r_type != R_PPC64_TOC)
14305                 {
14306                   BFD_ASSERT (h->elf.dynindx != -1);
14307                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14308                 }
14309               else
14310                 {
14311                   /* This symbol is local, or marked to become local,
14312                      or this is an opd section reloc which must point
14313                      at a local function.  */
14314                   outrel.r_addend += relocation;
14315                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14316                     {
14317                       if (is_opd && h != NULL)
14318                         {
14319                           /* Lie about opd entries.  This case occurs
14320                              when building shared libraries and we
14321                              reference a function in another shared
14322                              lib.  The same thing happens for a weak
14323                              definition in an application that's
14324                              overridden by a strong definition in a
14325                              shared lib.  (I believe this is a generic
14326                              bug in binutils handling of weak syms.)
14327                              In these cases we won't use the opd
14328                              entry in this lib.  */
14329                           unresolved_reloc = FALSE;
14330                         }
14331                       if (!is_opd
14332                           && r_type == R_PPC64_ADDR64
14333                           && (h != NULL
14334                               ? h->elf.type == STT_GNU_IFUNC
14335                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14336                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14337                       else
14338                         {
14339                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14340
14341                           /* We need to relocate .opd contents for ld.so.
14342                              Prelink also wants simple and consistent rules
14343                              for relocs.  This make all RELATIVE relocs have
14344                              *r_offset equal to r_addend.  */
14345                           relocate = TRUE;
14346                         }
14347                     }
14348                   else
14349                     {
14350                       long indx = 0;
14351
14352                       if (h != NULL
14353                           ? h->elf.type == STT_GNU_IFUNC
14354                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14355                         {
14356                           info->callbacks->einfo
14357                             (_("%P: %H: %s for indirect "
14358                                "function `%T' unsupported\n"),
14359                              input_bfd, input_section, rel->r_offset,
14360                              ppc64_elf_howto_table[r_type]->name,
14361                              sym_name);
14362                           ret = FALSE;
14363                         }
14364                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14365                         ;
14366                       else if (sec == NULL || sec->owner == NULL)
14367                         {
14368                           bfd_set_error (bfd_error_bad_value);
14369                           return FALSE;
14370                         }
14371                       else
14372                         {
14373                           asection *osec;
14374
14375                           osec = sec->output_section;
14376                           indx = elf_section_data (osec)->dynindx;
14377
14378                           if (indx == 0)
14379                             {
14380                               if ((osec->flags & SEC_READONLY) == 0
14381                                   && htab->elf.data_index_section != NULL)
14382                                 osec = htab->elf.data_index_section;
14383                               else
14384                                 osec = htab->elf.text_index_section;
14385                               indx = elf_section_data (osec)->dynindx;
14386                             }
14387                           BFD_ASSERT (indx != 0);
14388
14389                           /* We are turning this relocation into one
14390                              against a section symbol, so subtract out
14391                              the output section's address but not the
14392                              offset of the input section in the output
14393                              section.  */
14394                           outrel.r_addend -= osec->vma;
14395                         }
14396
14397                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14398                     }
14399                 }
14400
14401               sreloc = elf_section_data (input_section)->sreloc;
14402               if (h != NULL
14403                   ? h->elf.type == STT_GNU_IFUNC
14404                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14405                 sreloc = htab->elf.irelplt;
14406               if (sreloc == NULL)
14407                 abort ();
14408
14409               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14410                   >= sreloc->size)
14411                 abort ();
14412               loc = sreloc->contents;
14413               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14414               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14415
14416               /* If this reloc is against an external symbol, it will
14417                  be computed at runtime, so there's no need to do
14418                  anything now.  However, for the sake of prelink ensure
14419                  that the section contents are a known value.  */
14420               if (! relocate)
14421                 {
14422                   unresolved_reloc = FALSE;
14423                   /* The value chosen here is quite arbitrary as ld.so
14424                      ignores section contents except for the special
14425                      case of .opd where the contents might be accessed
14426                      before relocation.  Choose zero, as that won't
14427                      cause reloc overflow.  */
14428                   relocation = 0;
14429                   addend = 0;
14430                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14431                      to improve backward compatibility with older
14432                      versions of ld.  */
14433                   if (r_type == R_PPC64_ADDR64)
14434                     addend = outrel.r_addend;
14435                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14436                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14437                     addend = (input_section->output_section->vma
14438                               + input_section->output_offset
14439                               + rel->r_offset);
14440                 }
14441             }
14442           break;
14443
14444         case R_PPC64_COPY:
14445         case R_PPC64_GLOB_DAT:
14446         case R_PPC64_JMP_SLOT:
14447         case R_PPC64_JMP_IREL:
14448         case R_PPC64_RELATIVE:
14449           /* We shouldn't ever see these dynamic relocs in relocatable
14450              files.  */
14451           /* Fall through.  */
14452
14453         case R_PPC64_PLTGOT16:
14454         case R_PPC64_PLTGOT16_DS:
14455         case R_PPC64_PLTGOT16_HA:
14456         case R_PPC64_PLTGOT16_HI:
14457         case R_PPC64_PLTGOT16_LO:
14458         case R_PPC64_PLTGOT16_LO_DS:
14459         case R_PPC64_PLTREL32:
14460         case R_PPC64_PLTREL64:
14461           /* These ones haven't been implemented yet.  */
14462
14463           info->callbacks->einfo
14464             (_("%P: %B: %s is not supported for `%T'\n"),
14465              input_bfd,
14466              ppc64_elf_howto_table[r_type]->name, sym_name);
14467
14468           bfd_set_error (bfd_error_invalid_operation);
14469           ret = FALSE;
14470           continue;
14471         }
14472
14473       /* Multi-instruction sequences that access the TOC can be
14474          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14475          to             nop;           addi rb,r2,x;  */
14476       switch (r_type)
14477         {
14478         default:
14479           break;
14480
14481         case R_PPC64_GOT_TLSLD16_HI:
14482         case R_PPC64_GOT_TLSGD16_HI:
14483         case R_PPC64_GOT_TPREL16_HI:
14484         case R_PPC64_GOT_DTPREL16_HI:
14485         case R_PPC64_GOT16_HI:
14486         case R_PPC64_TOC16_HI:
14487           /* These relocs would only be useful if building up an
14488              offset to later add to r2, perhaps in an indexed
14489              addressing mode instruction.  Don't try to optimize.
14490              Unfortunately, the possibility of someone building up an
14491              offset like this or even with the HA relocs, means that
14492              we need to check the high insn when optimizing the low
14493              insn.  */
14494           break;
14495
14496         case R_PPC64_GOT_TLSLD16_HA:
14497         case R_PPC64_GOT_TLSGD16_HA:
14498         case R_PPC64_GOT_TPREL16_HA:
14499         case R_PPC64_GOT_DTPREL16_HA:
14500         case R_PPC64_GOT16_HA:
14501         case R_PPC64_TOC16_HA:
14502           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14503               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14504             {
14505               bfd_byte *p = contents + (rel->r_offset & ~3);
14506               bfd_put_32 (input_bfd, NOP, p);
14507             }
14508           break;
14509
14510         case R_PPC64_GOT_TLSLD16_LO:
14511         case R_PPC64_GOT_TLSGD16_LO:
14512         case R_PPC64_GOT_TPREL16_LO_DS:
14513         case R_PPC64_GOT_DTPREL16_LO_DS:
14514         case R_PPC64_GOT16_LO:
14515         case R_PPC64_GOT16_LO_DS:
14516         case R_PPC64_TOC16_LO:
14517         case R_PPC64_TOC16_LO_DS:
14518           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14519               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14520             {
14521               bfd_byte *p = contents + (rel->r_offset & ~3);
14522               insn = bfd_get_32 (input_bfd, p);
14523               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14524                 {
14525                   /* Transform addic to addi when we change reg.  */
14526                   insn &= ~((0x3f << 26) | (0x1f << 16));
14527                   insn |= (14u << 26) | (2 << 16);
14528                 }
14529               else
14530                 {
14531                   insn &= ~(0x1f << 16);
14532                   insn |= 2 << 16;
14533                 }
14534               bfd_put_32 (input_bfd, insn, p);
14535             }
14536           break;
14537         }
14538
14539       /* Do any further special processing.  */
14540       howto = ppc64_elf_howto_table[(int) r_type];
14541       switch (r_type)
14542         {
14543         default:
14544           break;
14545
14546         case R_PPC64_REL16_HA:
14547         case R_PPC64_ADDR16_HA:
14548         case R_PPC64_ADDR16_HIGHA:
14549         case R_PPC64_ADDR16_HIGHERA:
14550         case R_PPC64_ADDR16_HIGHESTA:
14551         case R_PPC64_TOC16_HA:
14552         case R_PPC64_SECTOFF_HA:
14553         case R_PPC64_TPREL16_HA:
14554         case R_PPC64_TPREL16_HIGHA:
14555         case R_PPC64_TPREL16_HIGHERA:
14556         case R_PPC64_TPREL16_HIGHESTA:
14557         case R_PPC64_DTPREL16_HA:
14558         case R_PPC64_DTPREL16_HIGHA:
14559         case R_PPC64_DTPREL16_HIGHERA:
14560         case R_PPC64_DTPREL16_HIGHESTA:
14561           /* It's just possible that this symbol is a weak symbol
14562              that's not actually defined anywhere. In that case,
14563              'sec' would be NULL, and we should leave the symbol
14564              alone (it will be set to zero elsewhere in the link).  */
14565           if (sec == NULL)
14566             break;
14567           /* Fall thru */
14568
14569         case R_PPC64_GOT16_HA:
14570         case R_PPC64_PLTGOT16_HA:
14571         case R_PPC64_PLT16_HA:
14572         case R_PPC64_GOT_TLSGD16_HA:
14573         case R_PPC64_GOT_TLSLD16_HA:
14574         case R_PPC64_GOT_TPREL16_HA:
14575         case R_PPC64_GOT_DTPREL16_HA:
14576           /* Add 0x10000 if sign bit in 0:15 is set.
14577              Bits 0:15 are not used.  */
14578           addend += 0x8000;
14579           break;
14580
14581         case R_PPC64_ADDR16_DS:
14582         case R_PPC64_ADDR16_LO_DS:
14583         case R_PPC64_GOT16_DS:
14584         case R_PPC64_GOT16_LO_DS:
14585         case R_PPC64_PLT16_LO_DS:
14586         case R_PPC64_SECTOFF_DS:
14587         case R_PPC64_SECTOFF_LO_DS:
14588         case R_PPC64_TOC16_DS:
14589         case R_PPC64_TOC16_LO_DS:
14590         case R_PPC64_PLTGOT16_DS:
14591         case R_PPC64_PLTGOT16_LO_DS:
14592         case R_PPC64_GOT_TPREL16_DS:
14593         case R_PPC64_GOT_TPREL16_LO_DS:
14594         case R_PPC64_GOT_DTPREL16_DS:
14595         case R_PPC64_GOT_DTPREL16_LO_DS:
14596         case R_PPC64_TPREL16_DS:
14597         case R_PPC64_TPREL16_LO_DS:
14598         case R_PPC64_DTPREL16_DS:
14599         case R_PPC64_DTPREL16_LO_DS:
14600           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14601           mask = 3;
14602           /* If this reloc is against an lq insn, then the value must be
14603              a multiple of 16.  This is somewhat of a hack, but the
14604              "correct" way to do this by defining _DQ forms of all the
14605              _DS relocs bloats all reloc switches in this file.  It
14606              doesn't seem to make much sense to use any of these relocs
14607              in data, so testing the insn should be safe.  */
14608           if ((insn & (0x3f << 26)) == (56u << 26))
14609             mask = 15;
14610           if (((relocation + addend) & mask) != 0)
14611             {
14612               info->callbacks->einfo
14613                 (_("%P: %H: error: %s not a multiple of %u\n"),
14614                  input_bfd, input_section, rel->r_offset,
14615                  howto->name,
14616                  mask + 1);
14617               bfd_set_error (bfd_error_bad_value);
14618               ret = FALSE;
14619               continue;
14620             }
14621           break;
14622         }
14623
14624       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14625          because such sections are not SEC_ALLOC and thus ld.so will
14626          not process them.  */
14627       if (unresolved_reloc
14628           && !((input_section->flags & SEC_DEBUGGING) != 0
14629                && h->elf.def_dynamic)
14630           && _bfd_elf_section_offset (output_bfd, info, input_section,
14631                                       rel->r_offset) != (bfd_vma) -1)
14632         {
14633           info->callbacks->einfo
14634             (_("%P: %H: unresolvable %s against `%T'\n"),
14635              input_bfd, input_section, rel->r_offset,
14636              howto->name,
14637              h->elf.root.root.string);
14638           ret = FALSE;
14639         }
14640
14641       /* 16-bit fields in insns mostly have signed values, but a
14642          few insns have 16-bit unsigned values.  Really, we should
14643          have different reloc types.  */
14644       if (howto->complain_on_overflow != complain_overflow_dont
14645           && howto->dst_mask == 0xffff
14646           && (input_section->flags & SEC_CODE) != 0)
14647         {
14648           enum complain_overflow complain = complain_overflow_signed;
14649
14650           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14651           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14652             complain = complain_overflow_bitfield;
14653           else if (howto->rightshift == 0
14654                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14655                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14656                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14657                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14658                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14659                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14660             complain = complain_overflow_unsigned;
14661           if (howto->complain_on_overflow != complain)
14662             {
14663               alt_howto = *howto;
14664               alt_howto.complain_on_overflow = complain;
14665               howto = &alt_howto;
14666             }
14667         }
14668
14669       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14670                                     rel->r_offset, relocation, addend);
14671
14672       if (r != bfd_reloc_ok)
14673         {
14674           char *more_info = NULL;
14675           const char *reloc_name = howto->name;
14676
14677           if (reloc_dest != DEST_NORMAL)
14678             {
14679               more_info = bfd_malloc (strlen (reloc_name) + 8);
14680               if (more_info != NULL)
14681                 {
14682                   strcpy (more_info, reloc_name);
14683                   strcat (more_info, (reloc_dest == DEST_OPD
14684                                       ? " (OPD)" : " (stub)"));
14685                   reloc_name = more_info;
14686                 }
14687             }
14688
14689           if (r == bfd_reloc_overflow)
14690             {
14691               if (warned)
14692                 continue;
14693               if (h != NULL
14694                   && h->elf.root.type == bfd_link_hash_undefweak
14695                   && howto->pc_relative)
14696                 {
14697                   /* Assume this is a call protected by other code that
14698                      detects the symbol is undefined.  If this is the case,
14699                      we can safely ignore the overflow.  If not, the
14700                      program is hosed anyway, and a little warning isn't
14701                      going to help.  */
14702
14703                   continue;
14704                 }
14705
14706               if (!((*info->callbacks->reloc_overflow)
14707                     (info, &h->elf.root, sym_name,
14708                      reloc_name, orig_rel.r_addend,
14709                      input_bfd, input_section, rel->r_offset)))
14710                 return FALSE;
14711             }
14712           else
14713             {
14714               info->callbacks->einfo
14715                 (_("%P: %H: %s against `%T': error %d\n"),
14716                  input_bfd, input_section, rel->r_offset,
14717                  reloc_name, sym_name, (int) r);
14718               ret = FALSE;
14719             }
14720           if (more_info != NULL)
14721             free (more_info);
14722         }
14723     }
14724
14725   /* If we're emitting relocations, then shortly after this function
14726      returns, reloc offsets and addends for this section will be
14727      adjusted.  Worse, reloc symbol indices will be for the output
14728      file rather than the input.  Save a copy of the relocs for
14729      opd_entry_value.  */
14730   if (is_opd && (info->emitrelocations || info->relocatable))
14731     {
14732       bfd_size_type amt;
14733       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14734       rel = bfd_alloc (input_bfd, amt);
14735       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14736       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14737       if (rel == NULL)
14738         return FALSE;
14739       memcpy (rel, relocs, amt);
14740     }
14741   return ret;
14742 }
14743
14744 /* Adjust the value of any local symbols in opd sections.  */
14745
14746 static int
14747 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14748                               const char *name ATTRIBUTE_UNUSED,
14749                               Elf_Internal_Sym *elfsym,
14750                               asection *input_sec,
14751                               struct elf_link_hash_entry *h)
14752 {
14753   struct _opd_sec_data *opd;
14754   long adjust;
14755   bfd_vma value;
14756
14757   if (h != NULL)
14758     return 1;
14759
14760   opd = get_opd_info (input_sec);
14761   if (opd == NULL || opd->adjust == NULL)
14762     return 1;
14763
14764   value = elfsym->st_value - input_sec->output_offset;
14765   if (!info->relocatable)
14766     value -= input_sec->output_section->vma;
14767
14768   adjust = opd->adjust[value / 8];
14769   if (adjust == -1)
14770     return 2;
14771
14772   elfsym->st_value += adjust;
14773   return 1;
14774 }
14775
14776 /* Finish up dynamic symbol handling.  We set the contents of various
14777    dynamic sections here.  */
14778
14779 static bfd_boolean
14780 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14781                                  struct bfd_link_info *info,
14782                                  struct elf_link_hash_entry *h,
14783                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14784 {
14785   struct ppc_link_hash_table *htab;
14786   struct plt_entry *ent;
14787   Elf_Internal_Rela rela;
14788   bfd_byte *loc;
14789
14790   htab = ppc_hash_table (info);
14791   if (htab == NULL)
14792     return FALSE;
14793
14794   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14795     if (ent->plt.offset != (bfd_vma) -1)
14796       {
14797         /* This symbol has an entry in the procedure linkage
14798            table.  Set it up.  */
14799         if (!htab->elf.dynamic_sections_created
14800             || h->dynindx == -1)
14801           {
14802             BFD_ASSERT (h->type == STT_GNU_IFUNC
14803                         && h->def_regular
14804                         && (h->root.type == bfd_link_hash_defined
14805                             || h->root.type == bfd_link_hash_defweak));
14806             rela.r_offset = (htab->elf.iplt->output_section->vma
14807                              + htab->elf.iplt->output_offset
14808                              + ent->plt.offset);
14809             if (htab->opd_abi)
14810               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14811             else
14812               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14813             rela.r_addend = (h->root.u.def.value
14814                              + h->root.u.def.section->output_offset
14815                              + h->root.u.def.section->output_section->vma
14816                              + ent->addend);
14817             loc = (htab->elf.irelplt->contents
14818                    + (htab->elf.irelplt->reloc_count++
14819                       * sizeof (Elf64_External_Rela)));
14820           }
14821         else
14822           {
14823             rela.r_offset = (htab->elf.splt->output_section->vma
14824                              + htab->elf.splt->output_offset
14825                              + ent->plt.offset);
14826             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14827             rela.r_addend = ent->addend;
14828             loc = (htab->elf.srelplt->contents
14829                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14830                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14831           }
14832         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14833
14834         if (!htab->opd_abi)
14835           {
14836             if (!h->def_regular)
14837               {
14838                 /* Mark the symbol as undefined, rather than as
14839                    defined in glink.  Leave the value if there were
14840                    any relocations where pointer equality matters
14841                    (this is a clue for the dynamic linker, to make
14842                    function pointer comparisons work between an
14843                    application and shared library), otherwise set it
14844                    to zero.  */
14845                 sym->st_shndx = SHN_UNDEF;
14846                 if (!h->pointer_equality_needed)
14847                   sym->st_value = 0;
14848                 else if (!h->ref_regular_nonweak)
14849                   {
14850                     /* This breaks function pointer comparisons, but
14851                        that is better than breaking tests for a NULL
14852                        function pointer.  */
14853                     sym->st_value = 0;
14854                   }
14855               }
14856           }
14857       }
14858
14859   if (h->needs_copy)
14860     {
14861       /* This symbol needs a copy reloc.  Set it up.  */
14862
14863       if (h->dynindx == -1
14864           || (h->root.type != bfd_link_hash_defined
14865               && h->root.type != bfd_link_hash_defweak)
14866           || htab->relbss == NULL)
14867         abort ();
14868
14869       rela.r_offset = (h->root.u.def.value
14870                        + h->root.u.def.section->output_section->vma
14871                        + h->root.u.def.section->output_offset);
14872       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14873       rela.r_addend = 0;
14874       loc = htab->relbss->contents;
14875       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14876       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14877     }
14878
14879   return TRUE;
14880 }
14881
14882 /* Used to decide how to sort relocs in an optimal manner for the
14883    dynamic linker, before writing them out.  */
14884
14885 static enum elf_reloc_type_class
14886 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14887                             const asection *rel_sec,
14888                             const Elf_Internal_Rela *rela)
14889 {
14890   enum elf_ppc64_reloc_type r_type;
14891   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14892
14893   if (rel_sec == htab->elf.irelplt)
14894     return reloc_class_ifunc;
14895
14896   r_type = ELF64_R_TYPE (rela->r_info);
14897   switch (r_type)
14898     {
14899     case R_PPC64_RELATIVE:
14900       return reloc_class_relative;
14901     case R_PPC64_JMP_SLOT:
14902       return reloc_class_plt;
14903     case R_PPC64_COPY:
14904       return reloc_class_copy;
14905     default:
14906       return reloc_class_normal;
14907     }
14908 }
14909
14910 /* Finish up the dynamic sections.  */
14911
14912 static bfd_boolean
14913 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14914                                    struct bfd_link_info *info)
14915 {
14916   struct ppc_link_hash_table *htab;
14917   bfd *dynobj;
14918   asection *sdyn;
14919
14920   htab = ppc_hash_table (info);
14921   if (htab == NULL)
14922     return FALSE;
14923
14924   dynobj = htab->elf.dynobj;
14925   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14926
14927   if (htab->elf.dynamic_sections_created)
14928     {
14929       Elf64_External_Dyn *dyncon, *dynconend;
14930
14931       if (sdyn == NULL || htab->elf.sgot == NULL)
14932         abort ();
14933
14934       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14935       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14936       for (; dyncon < dynconend; dyncon++)
14937         {
14938           Elf_Internal_Dyn dyn;
14939           asection *s;
14940
14941           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14942
14943           switch (dyn.d_tag)
14944             {
14945             default:
14946               continue;
14947
14948             case DT_PPC64_GLINK:
14949               s = htab->glink;
14950               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14951               /* We stupidly defined DT_PPC64_GLINK to be the start
14952                  of glink rather than the first entry point, which is
14953                  what ld.so needs, and now have a bigger stub to
14954                  support automatic multiple TOCs.  */
14955               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14956               break;
14957
14958             case DT_PPC64_OPD:
14959               s = bfd_get_section_by_name (output_bfd, ".opd");
14960               if (s == NULL)
14961                 continue;
14962               dyn.d_un.d_ptr = s->vma;
14963               break;
14964
14965             case DT_PPC64_OPT:
14966               if (htab->do_multi_toc && htab->multi_toc_needed)
14967                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14968               break;
14969
14970             case DT_PPC64_OPDSZ:
14971               s = bfd_get_section_by_name (output_bfd, ".opd");
14972               if (s == NULL)
14973                 continue;
14974               dyn.d_un.d_val = s->size;
14975               break;
14976
14977             case DT_PLTGOT:
14978               s = htab->elf.splt;
14979               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14980               break;
14981
14982             case DT_JMPREL:
14983               s = htab->elf.srelplt;
14984               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14985               break;
14986
14987             case DT_PLTRELSZ:
14988               dyn.d_un.d_val = htab->elf.srelplt->size;
14989               break;
14990
14991             case DT_RELASZ:
14992               /* Don't count procedure linkage table relocs in the
14993                  overall reloc count.  */
14994               s = htab->elf.srelplt;
14995               if (s == NULL)
14996                 continue;
14997               dyn.d_un.d_val -= s->size;
14998               break;
14999
15000             case DT_RELA:
15001               /* We may not be using the standard ELF linker script.
15002                  If .rela.plt is the first .rela section, we adjust
15003                  DT_RELA to not include it.  */
15004               s = htab->elf.srelplt;
15005               if (s == NULL)
15006                 continue;
15007               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15008                 continue;
15009               dyn.d_un.d_ptr += s->size;
15010               break;
15011             }
15012
15013           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15014         }
15015     }
15016
15017   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15018     {
15019       /* Fill in the first entry in the global offset table.
15020          We use it to hold the link-time TOCbase.  */
15021       bfd_put_64 (output_bfd,
15022                   elf_gp (output_bfd) + TOC_BASE_OFF,
15023                   htab->elf.sgot->contents);
15024
15025       /* Set .got entry size.  */
15026       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15027     }
15028
15029   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15030     {
15031       /* Set .plt entry size.  */
15032       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15033         = PLT_ENTRY_SIZE (htab);
15034     }
15035
15036   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15037      brlt ourselves if emitrelocations.  */
15038   if (htab->brlt != NULL
15039       && htab->brlt->reloc_count != 0
15040       && !_bfd_elf_link_output_relocs (output_bfd,
15041                                        htab->brlt,
15042                                        elf_section_data (htab->brlt)->rela.hdr,
15043                                        elf_section_data (htab->brlt)->relocs,
15044                                        NULL))
15045     return FALSE;
15046
15047   if (htab->glink != NULL
15048       && htab->glink->reloc_count != 0
15049       && !_bfd_elf_link_output_relocs (output_bfd,
15050                                        htab->glink,
15051                                        elf_section_data (htab->glink)->rela.hdr,
15052                                        elf_section_data (htab->glink)->relocs,
15053                                        NULL))
15054     return FALSE;
15055
15056
15057   if (htab->glink_eh_frame != NULL
15058       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15059       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15060                                            htab->glink_eh_frame,
15061                                            htab->glink_eh_frame->contents))
15062     return FALSE;
15063
15064   /* We need to handle writing out multiple GOT sections ourselves,
15065      since we didn't add them to DYNOBJ.  We know dynobj is the first
15066      bfd.  */
15067   while ((dynobj = dynobj->link_next) != NULL)
15068     {
15069       asection *s;
15070
15071       if (!is_ppc64_elf (dynobj))
15072         continue;
15073
15074       s = ppc64_elf_tdata (dynobj)->got;
15075       if (s != NULL
15076           && s->size != 0
15077           && s->output_section != bfd_abs_section_ptr
15078           && !bfd_set_section_contents (output_bfd, s->output_section,
15079                                         s->contents, s->output_offset,
15080                                         s->size))
15081         return FALSE;
15082       s = ppc64_elf_tdata (dynobj)->relgot;
15083       if (s != NULL
15084           && s->size != 0
15085           && s->output_section != bfd_abs_section_ptr
15086           && !bfd_set_section_contents (output_bfd, s->output_section,
15087                                         s->contents, s->output_offset,
15088                                         s->size))
15089         return FALSE;
15090     }
15091
15092   return TRUE;
15093 }
15094
15095 #include "elf64-target.h"
15096
15097 /* FreeBSD support */
15098
15099 #undef  TARGET_LITTLE_SYM
15100 #undef  TARGET_LITTLE_NAME
15101
15102 #undef  TARGET_BIG_SYM
15103 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15104 #undef  TARGET_BIG_NAME
15105 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15106
15107 #undef  ELF_OSABI
15108 #define ELF_OSABI       ELFOSABI_FREEBSD
15109
15110 #undef  elf64_bed
15111 #define elf64_bed       elf64_powerpc_fbsd_bed
15112
15113 #include "elf64-target.h"
15114