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_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141
 142 /* Offset of tp and dtp pointers from start of TLS block.  */
 143 #define TP_OFFSET       0x7000
 144 #define DTP_OFFSET      0x8000
 145
 146 /* .plt call stub instructions.  The normal stub is like this, but
 147    sometimes the .plt entry crosses a 64k boundary and we need to
 148    insert an addi to adjust r11.  */
 149 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 150 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 151 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 152 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 153 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 154 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 155 #define BCTR            0x4e800420      /* bctr                      */
 156
 157 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 158 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 159 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 160
 161 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 162 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 163 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 164 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 165 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 166 #define BNECTR          0x4ca20420      /* bnectr+               */
 167 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 168
 169 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 170 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 171 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 172
 173 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 174
 175 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 176 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 177 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 178
 179 /* glink call stub instructions.  We enter with the index in R0.  */
 180 #define GLINK_CALL_STUB_SIZE (16*4)
 181                                         /* 0:                           */
 182                                         /*  .quad plt0-1f               */
 183                                         /* __glink:                     */
 184 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 185 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 186                                         /* 1:                           */
 187 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 188                                         /*  ld %2,(0b-1b)(%11)          */
 189 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 190 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 191                                         /*  ld %12,0(%11)               */
 192                                         /*  ld %2,8(%11)                */
 193                                         /*  mtctr %12                   */
 194                                         /*  ld %11,16(%11)              */
 195                                         /*  bctr                        */
 196 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 197 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 198 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 199 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 200 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 201
 202 /* Pad with this.  */
 203 #define NOP             0x60000000
 204
 205 /* Some other nops.  */
 206 #define CROR_151515     0x4def7b82
 207 #define CROR_313131     0x4ffffb82
 208
 209 /* .glink entries for the first 32k functions are two instructions.  */
 210 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 211 #define B_DOT           0x48000000      /* b     .              */
 212
 213 /* After that, we need two instructions to load the index, followed by
 214    a branch.  */
 215 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 216 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 217
 218 /* Instructions used by the save and restore reg functions.  */
 219 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 220 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 221 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 222 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 223 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 224 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 225 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 226 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 227 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 228 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 229 #define BLR             0x4e800020      /* blr                  */
 230
 231 /* Since .opd is an array of descriptors and each entry will end up
 232    with identical R_PPC64_RELATIVE relocs, there is really no need to
 233    propagate .opd relocs;  The dynamic linker should be taught to
 234    relocate .opd without reloc entries.  */
 235 #ifndef NO_OPD_RELOCS
 236 #define NO_OPD_RELOCS 0
 237 #endif
 238 \f
 239 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 240
 241 /* Relocation HOWTO's.  */
 242 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 243
 244 static reloc_howto_type ppc64_elf_howto_raw[] = {
 245   /* This reloc does nothing.  */
 246   HOWTO (R_PPC64_NONE,          /* type */
 247          0,                     /* rightshift */
 248          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 249          32,                    /* bitsize */
 250          FALSE,                 /* pc_relative */
 251          0,                     /* bitpos */
 252          complain_overflow_dont, /* complain_on_overflow */
 253          bfd_elf_generic_reloc, /* special_function */
 254          "R_PPC64_NONE",        /* name */
 255          FALSE,                 /* partial_inplace */
 256          0,                     /* src_mask */
 257          0,                     /* dst_mask */
 258          FALSE),                /* pcrel_offset */
 259
 260   /* A standard 32 bit relocation.  */
 261   HOWTO (R_PPC64_ADDR32,        /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          32,                    /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_bitfield, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_PPC64_ADDR32",      /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0xffffffff,            /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* An absolute 26 bit branch; the lower two bits must be zero.
 276      FIXME: we don't check that, we just clear them.  */
 277   HOWTO (R_PPC64_ADDR24,        /* type */
 278          0,                     /* rightshift */
 279          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          26,                    /* bitsize */
 281          FALSE,                 /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_bitfield, /* complain_on_overflow */
 284          bfd_elf_generic_reloc, /* special_function */
 285          "R_PPC64_ADDR24",      /* name */
 286          FALSE,                 /* partial_inplace */
 287          0,                     /* src_mask */
 288          0x03fffffc,            /* dst_mask */
 289          FALSE),                /* pcrel_offset */
 290
 291   /* A standard 16 bit relocation.  */
 292   HOWTO (R_PPC64_ADDR16,        /* type */
 293          0,                     /* rightshift */
 294          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          16,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_bitfield, /* complain_on_overflow */
 299          bfd_elf_generic_reloc, /* special_function */
 300          "R_PPC64_ADDR16",      /* name */
 301          FALSE,                 /* partial_inplace */
 302          0,                     /* src_mask */
 303          0xffff,                /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* A 16 bit relocation without overflow.  */
 307   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 308          0,                     /* rightshift */
 309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          16,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_dont,/* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_PPC64_ADDR16_LO",   /* name */
 316          FALSE,                 /* partial_inplace */
 317          0,                     /* src_mask */
 318          0xffff,                /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* Bits 16-31 of an address.  */
 322   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 323          16,                    /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_signed, /* complain_on_overflow */
 329          bfd_elf_generic_reloc, /* special_function */
 330          "R_PPC64_ADDR16_HI",   /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 337      bits, treated as a signed number, is negative.  */
 338   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 339          16,                    /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_signed, /* complain_on_overflow */
 345          ppc64_elf_ha_reloc,    /* special_function */
 346          "R_PPC64_ADDR16_HA",   /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0xffff,                /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* An absolute 16 bit branch; the lower two bits must be zero.
 353      FIXME: we don't check that, we just clear them.  */
 354   HOWTO (R_PPC64_ADDR14,        /* type */
 355          0,                     /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_signed, /* complain_on_overflow */
 361          ppc64_elf_branch_reloc, /* special_function */
 362          "R_PPC64_ADDR14",      /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0x0000fffc,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* An absolute 16 bit branch, for which bit 10 should be set to
 369      indicate that the branch is expected to be taken.  The lower two
 370      bits must be zero.  */
 371   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 372          0,                     /* rightshift */
 373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          16,                    /* bitsize */
 375          FALSE,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_signed, /* complain_on_overflow */
 378          ppc64_elf_brtaken_reloc, /* special_function */
 379          "R_PPC64_ADDR14_BRTAKEN",/* name */
 380          FALSE,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0x0000fffc,            /* dst_mask */
 383          FALSE),                /* pcrel_offset */
 384
 385   /* An absolute 16 bit branch, for which bit 10 should be set to
 386      indicate that the branch is not expected to be taken.  The lower
 387      two bits must be zero.  */
 388   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 389          0,                     /* rightshift */
 390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 391          16,                    /* bitsize */
 392          FALSE,                 /* pc_relative */
 393          0,                     /* bitpos */
 394          complain_overflow_signed, /* complain_on_overflow */
 395          ppc64_elf_brtaken_reloc, /* special_function */
 396          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 397          FALSE,                 /* partial_inplace */
 398          0,                     /* src_mask */
 399          0x0000fffc,            /* dst_mask */
 400          FALSE),                /* pcrel_offset */
 401
 402   /* A relative 26 bit branch; the lower two bits must be zero.  */
 403   HOWTO (R_PPC64_REL24,         /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          26,                    /* bitsize */
 407          TRUE,                  /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_branch_reloc, /* special_function */
 411          "R_PPC64_REL24",       /* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x03fffffc,            /* dst_mask */
 415          TRUE),                 /* pcrel_offset */
 416
 417   /* A relative 16 bit branch; the lower two bits must be zero.  */
 418   HOWTO (R_PPC64_REL14,         /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          16,                    /* bitsize */
 422          TRUE,                  /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          ppc64_elf_branch_reloc, /* special_function */
 426          "R_PPC64_REL14",       /* name */
 427          FALSE,                 /* partial_inplace */
 428          0,                     /* src_mask */
 429          0x0000fffc,            /* dst_mask */
 430          TRUE),                 /* pcrel_offset */
 431
 432   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 433      the branch is expected to be taken.  The lower two bits must be
 434      zero.  */
 435   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          16,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_brtaken_reloc, /* special_function */
 443          "R_PPC64_REL14_BRTAKEN", /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x0000fffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 450      the branch is not expected to be taken.  The lower two bits must
 451      be zero.  */
 452   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 453          0,                     /* rightshift */
 454          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          16,                    /* bitsize */
 456          TRUE,                  /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_signed, /* complain_on_overflow */
 459          ppc64_elf_brtaken_reloc, /* special_function */
 460          "R_PPC64_REL14_BRNTAKEN",/* name */
 461          FALSE,                 /* partial_inplace */
 462          0,                     /* src_mask */
 463          0x0000fffc,            /* dst_mask */
 464          TRUE),                 /* pcrel_offset */
 465
 466   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 467      symbol.  */
 468   HOWTO (R_PPC64_GOT16,         /* type */
 469          0,                     /* rightshift */
 470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_signed, /* complain_on_overflow */
 475          ppc64_elf_unhandled_reloc, /* special_function */
 476          "R_PPC64_GOT16",       /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0xffff,                /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 483      the symbol.  */
 484   HOWTO (R_PPC64_GOT16_LO,      /* type */
 485          0,                     /* rightshift */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont, /* complain_on_overflow */
 491          ppc64_elf_unhandled_reloc, /* special_function */
 492          "R_PPC64_GOT16_LO",    /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0xffff,                /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 499      the symbol.  */
 500   HOWTO (R_PPC64_GOT16_HI,      /* type */
 501          16,                    /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed,/* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16_HI",    /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_HA,      /* type */
 517          16,                    /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_signed,/* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_HA",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* This is used only by the dynamic linker.  The symbol should exist
 531      both in the object being run and in some shared library.  The
 532      dynamic linker copies the data addressed by the symbol from the
 533      shared library into the object, because the object being
 534      run has to have the data at some particular address.  */
 535   HOWTO (R_PPC64_COPY,          /* type */
 536          0,                     /* rightshift */
 537          0,                     /* this one is variable size */
 538          0,                     /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_dont, /* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc, /* special_function */
 543          "R_PPC64_COPY",        /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          0,                     /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* Like R_PPC64_ADDR64, but used when setting global offset table
 550      entries.  */
 551   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 552          0,                     /* rightshift */
 553          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 554          64,                    /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont, /* complain_on_overflow */
 558          ppc64_elf_unhandled_reloc,  /* special_function */
 559          "R_PPC64_GLOB_DAT",    /* name */
 560          FALSE,                 /* partial_inplace */
 561          0,                     /* src_mask */
 562          ONES (64),             /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564
 565   /* Created by the link editor.  Marks a procedure linkage table
 566      entry for a symbol.  */
 567   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 568          0,                     /* rightshift */
 569          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_JMP_SLOT",    /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Used only by the dynamic linker.  When the object is run, this
 582      doubleword64 is set to the load address of the object, plus the
 583      addend.  */
 584   HOWTO (R_PPC64_RELATIVE,      /* type */
 585          0,                     /* rightshift */
 586          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 587          64,                    /* bitsize */
 588          FALSE,                 /* pc_relative */
 589          0,                     /* bitpos */
 590          complain_overflow_dont, /* complain_on_overflow */
 591          bfd_elf_generic_reloc, /* special_function */
 592          "R_PPC64_RELATIVE",    /* name */
 593          FALSE,                 /* partial_inplace */
 594          0,                     /* src_mask */
 595          ONES (64),             /* dst_mask */
 596          FALSE),                /* pcrel_offset */
 597
 598   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 599   HOWTO (R_PPC64_UADDR32,       /* type */
 600          0,                     /* rightshift */
 601          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          32,                    /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_bitfield, /* complain_on_overflow */
 606          bfd_elf_generic_reloc, /* special_function */
 607          "R_PPC64_UADDR32",     /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0xffffffff,            /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 614   HOWTO (R_PPC64_UADDR16,       /* type */
 615          0,                     /* rightshift */
 616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 617          16,                    /* bitsize */
 618          FALSE,                 /* pc_relative */
 619          0,                     /* bitpos */
 620          complain_overflow_bitfield, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_UADDR16",     /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffff,                /* dst_mask */
 626          FALSE),                /* pcrel_offset */
 627
 628   /* 32-bit PC relative.  */
 629   HOWTO (R_PPC64_REL32,         /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          TRUE,                  /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_signed, /* complain_on_overflow */
 636          bfd_elf_generic_reloc, /* special_function */
 637          "R_PPC64_REL32",       /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          TRUE),                 /* pcrel_offset */
 642
 643   /* 32-bit relocation to the symbol's procedure linkage table.  */
 644   HOWTO (R_PPC64_PLT32,         /* type */
 645          0,                     /* rightshift */
 646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          32,                    /* bitsize */
 648          FALSE,                 /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_bitfield, /* complain_on_overflow */
 651          ppc64_elf_unhandled_reloc, /* special_function */
 652          "R_PPC64_PLT32",       /* name */
 653          FALSE,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffffffff,            /* dst_mask */
 656          FALSE),                /* pcrel_offset */
 657
 658   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 659      FIXME: R_PPC64_PLTREL32 not supported.  */
 660   HOWTO (R_PPC64_PLTREL32,      /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          32,                    /* bitsize */
 664          TRUE,                  /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_signed, /* complain_on_overflow */
 667          bfd_elf_generic_reloc, /* special_function */
 668          "R_PPC64_PLTREL32",    /* name */
 669          FALSE,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0xffffffff,            /* dst_mask */
 672          TRUE),                 /* pcrel_offset */
 673
 674   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 675      the symbol.  */
 676   HOWTO (R_PPC64_PLT16_LO,      /* type */
 677          0,                     /* rightshift */
 678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          16,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_dont, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT16_LO",    /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffff,                /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 691      the symbol.  */
 692   HOWTO (R_PPC64_PLT16_HI,      /* type */
 693          16,                    /* rightshift */
 694          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          16,                    /* bitsize */
 696          FALSE,                 /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLT16_HI",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffff,                /* dst_mask */
 704          FALSE),                /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_HA,      /* type */
 709          16,                    /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_signed, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_HA",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* 16-bit section relative relocation.  */
 723   HOWTO (R_PPC64_SECTOFF,       /* type */
 724          0,                     /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_signed, /* complain_on_overflow */
 730          ppc64_elf_sectoff_reloc, /* special_function */
 731          "R_PPC64_SECTOFF",     /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 738   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 739          0,                     /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF_LO",  /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit upper half section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 754          16,                    /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_signed, /* complain_on_overflow */
 760          ppc64_elf_sectoff_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_HI",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* 16-bit upper half adjusted section relative relocation.  */
 768   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 769          16,                    /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_signed, /* complain_on_overflow */
 775          ppc64_elf_sectoff_ha_reloc, /* special_function */
 776          "R_PPC64_SECTOFF_HA",  /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 783   HOWTO (R_PPC64_REL30,         /* type */
 784          2,                     /* rightshift */
 785          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          30,                    /* bitsize */
 787          TRUE,                  /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_dont, /* complain_on_overflow */
 790          bfd_elf_generic_reloc, /* special_function */
 791          "R_PPC64_REL30",       /* name */
 792          FALSE,                 /* partial_inplace */
 793          0,                     /* src_mask */
 794          0xfffffffc,            /* dst_mask */
 795          TRUE),                 /* pcrel_offset */
 796
 797   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 798
 799   /* A standard 64-bit relocation.  */
 800   HOWTO (R_PPC64_ADDR64,        /* type */
 801          0,                     /* rightshift */
 802          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 803          64,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_PPC64_ADDR64",      /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          ONES (64),             /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* The bits 32-47 of an address.  */
 815   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 816          32,                    /* rightshift */
 817          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          16,                    /* bitsize */
 819          FALSE,                 /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_ADDR16_HIGHER", /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xffff,                /* dst_mask */
 827          FALSE),                /* pcrel_offset */
 828
 829   /* The bits 32-47 of an address, plus 1 if the contents of the low
 830      16 bits, treated as a signed number, is negative.  */
 831   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 832          32,                    /* rightshift */
 833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 834          16,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          ppc64_elf_ha_reloc,    /* special_function */
 839          "R_PPC64_ADDR16_HIGHERA", /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          0xffff,                /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 48-63 of an address.  */
 846   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 847          48,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_dont, /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_PPC64_ADDR16_HIGHEST", /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* The bits 48-63 of an address, plus 1 if the contents of the low
 861      16 bits, treated as a signed number, is negative.  */
 862   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 863          48,                    /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          ppc64_elf_ha_reloc,    /* special_function */
 870          "R_PPC64_ADDR16_HIGHESTA", /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* Like ADDR64, but may be unaligned.  */
 877   HOWTO (R_PPC64_UADDR64,       /* type */
 878          0,                     /* rightshift */
 879          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 880          64,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_UADDR64",     /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          ONES (64),             /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* 64-bit relative relocation.  */
 892   HOWTO (R_PPC64_REL64,         /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          TRUE,                  /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_PPC64_REL64",       /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          TRUE),                 /* pcrel_offset */
 905
 906   /* 64-bit relocation to the symbol's procedure linkage table.  */
 907   HOWTO (R_PPC64_PLT64,         /* type */
 908          0,                     /* rightshift */
 909          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 910          64,                    /* bitsize */
 911          FALSE,                 /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont, /* complain_on_overflow */
 914          ppc64_elf_unhandled_reloc, /* special_function */
 915          "R_PPC64_PLT64",       /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          ONES (64),             /* dst_mask */
 919          FALSE),                /* pcrel_offset */
 920
 921   /* 64-bit PC relative relocation to the symbol's procedure linkage
 922      table.  */
 923   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 924   HOWTO (R_PPC64_PLTREL64,      /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          ppc64_elf_unhandled_reloc, /* special_function */
 932          "R_PPC64_PLTREL64",    /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 16 bit TOC-relative relocation.  */
 939
 940   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 941   HOWTO (R_PPC64_TOC16,         /* type */
 942          0,                     /* rightshift */
 943          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 944          16,                    /* bitsize */
 945          FALSE,                 /* pc_relative */
 946          0,                     /* bitpos */
 947          complain_overflow_signed, /* complain_on_overflow */
 948          ppc64_elf_toc_reloc,   /* special_function */
 949          "R_PPC64_TOC16",       /* name */
 950          FALSE,                 /* partial_inplace */
 951          0,                     /* src_mask */
 952          0xffff,                /* dst_mask */
 953          FALSE),                /* pcrel_offset */
 954
 955   /* 16 bit TOC-relative relocation without overflow.  */
 956
 957   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 958   HOWTO (R_PPC64_TOC16_LO,      /* type */
 959          0,                     /* rightshift */
 960          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 961          16,                    /* bitsize */
 962          FALSE,                 /* pc_relative */
 963          0,                     /* bitpos */
 964          complain_overflow_dont, /* complain_on_overflow */
 965          ppc64_elf_toc_reloc,   /* special_function */
 966          "R_PPC64_TOC16_LO",    /* name */
 967          FALSE,                 /* partial_inplace */
 968          0,                     /* src_mask */
 969          0xffff,                /* dst_mask */
 970          FALSE),                /* pcrel_offset */
 971
 972   /* 16 bit TOC-relative relocation, high 16 bits.  */
 973
 974   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 975   HOWTO (R_PPC64_TOC16_HI,      /* type */
 976          16,                    /* rightshift */
 977          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 978          16,                    /* bitsize */
 979          FALSE,                 /* pc_relative */
 980          0,                     /* bitpos */
 981          complain_overflow_signed, /* complain_on_overflow */
 982          ppc64_elf_toc_reloc,   /* special_function */
 983          "R_PPC64_TOC16_HI",    /* name */
 984          FALSE,                 /* partial_inplace */
 985          0,                     /* src_mask */
 986          0xffff,                /* dst_mask */
 987          FALSE),                /* pcrel_offset */
 988
 989   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 990      contents of the low 16 bits, treated as a signed number, is
 991      negative.  */
 992
 993   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 994   HOWTO (R_PPC64_TOC16_HA,      /* type */
 995          16,                    /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_toc_ha_reloc, /* special_function */
1002          "R_PPC64_TOC16_HA",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1009
1010   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1011   HOWTO (R_PPC64_TOC,           /* type */
1012          0,                     /* rightshift */
1013          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1014          64,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_dont, /* complain_on_overflow */
1018          ppc64_elf_toc64_reloc, /* special_function */
1019          "R_PPC64_TOC",         /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          ONES (64),             /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_GOT16, but also informs the link editor that the
1026      value to relocate may (!) refer to a PLT entry which the link
1027      editor (a) may replace with the symbol value.  If the link editor
1028      is unable to fully resolve the symbol, it may (b) create a PLT
1029      entry and store the address to the new PLT entry in the GOT.
1030      This permits lazy resolution of function symbols at run time.
1031      The link editor may also skip all of this and just (c) emit a
1032      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1033   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1034     HOWTO (R_PPC64_PLTGOT16,    /* type */
1035          0,                     /* rightshift */
1036          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1037          16,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_signed, /* complain_on_overflow */
1041          ppc64_elf_unhandled_reloc, /* special_function */
1042          "R_PPC64_PLTGOT16",    /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          0xffff,                /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1049   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1050   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1051          0,                     /* rightshift */
1052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1053          16,                    /* bitsize */
1054          FALSE,                 /* pc_relative */
1055          0,                     /* bitpos */
1056          complain_overflow_dont, /* complain_on_overflow */
1057          ppc64_elf_unhandled_reloc, /* special_function */
1058          "R_PPC64_PLTGOT16_LO", /* name */
1059          FALSE,                 /* partial_inplace */
1060          0,                     /* src_mask */
1061          0xffff,                /* dst_mask */
1062          FALSE),                /* pcrel_offset */
1063
1064   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1065   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1066   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1067          16,                    /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16_HI", /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1081      1 if the contents of the low 16 bits, treated as a signed number,
1082      is negative.  */
1083   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1084   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1085          16,                    /* rightshift */
1086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          16,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_signed, /* complain_on_overflow */
1091          ppc64_elf_unhandled_reloc, /* special_function */
1092          "R_PPC64_PLTGOT16_HA", /* name */
1093          FALSE,                 /* partial_inplace */
1094          0,                     /* src_mask */
1095          0xffff,                /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1099   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1100          0,                     /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_signed, /* complain_on_overflow */
1106          bfd_elf_generic_reloc, /* special_function */
1107          "R_PPC64_ADDR16_DS",   /* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xfffc,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_dont,/* complain_on_overflow */
1121          bfd_elf_generic_reloc, /* special_function */
1122          "R_PPC64_ADDR16_LO_DS",/* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_GOT16_DS,      /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_signed, /* complain_on_overflow */
1136          ppc64_elf_unhandled_reloc, /* special_function */
1137          "R_PPC64_GOT16_DS",    /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_GOT16_LO_DS", /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_dont, /* complain_on_overflow */
1166          ppc64_elf_unhandled_reloc, /* special_function */
1167          "R_PPC64_PLT16_LO_DS", /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_signed, /* complain_on_overflow */
1181          ppc64_elf_sectoff_reloc, /* special_function */
1182          "R_PPC64_SECTOFF_DS",  /* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont, /* complain_on_overflow */
1196          ppc64_elf_sectoff_reloc, /* special_function */
1197          "R_PPC64_SECTOFF_LO_DS",/* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_TOC16_DS,      /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_signed, /* complain_on_overflow */
1211          ppc64_elf_toc_reloc,   /* special_function */
1212          "R_PPC64_TOC16_DS",    /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1219   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1220          0,                     /* rightshift */
1221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          16,                    /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont, /* complain_on_overflow */
1226          ppc64_elf_toc_reloc,   /* special_function */
1227          "R_PPC64_TOC16_LO_DS", /* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0xfffc,                /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1234   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1235   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1236          0,                     /* rightshift */
1237          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1238          16,                    /* bitsize */
1239          FALSE,                 /* pc_relative */
1240          0,                     /* bitpos */
1241          complain_overflow_signed, /* complain_on_overflow */
1242          ppc64_elf_unhandled_reloc, /* special_function */
1243          "R_PPC64_PLTGOT16_DS", /* name */
1244          FALSE,                 /* partial_inplace */
1245          0,                     /* src_mask */
1246          0xfffc,                /* dst_mask */
1247          FALSE),                /* pcrel_offset */
1248
1249   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1250   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1251   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_unhandled_reloc, /* special_function */
1259          "R_PPC64_PLTGOT16_LO_DS",/* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Marker relocs for TLS.  */
1266   HOWTO (R_PPC64_TLS,
1267          0,                     /* rightshift */
1268          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          32,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_dont, /* complain_on_overflow */
1273          bfd_elf_generic_reloc, /* special_function */
1274          "R_PPC64_TLS",         /* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0,                     /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   HOWTO (R_PPC64_TLSGD,
1281          0,                     /* rightshift */
1282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1283          32,                    /* bitsize */
1284          FALSE,                 /* pc_relative */
1285          0,                     /* bitpos */
1286          complain_overflow_dont, /* complain_on_overflow */
1287          bfd_elf_generic_reloc, /* special_function */
1288          "R_PPC64_TLSGD",       /* name */
1289          FALSE,                 /* partial_inplace */
1290          0,                     /* src_mask */
1291          0,                     /* dst_mask */
1292          FALSE),                /* pcrel_offset */
1293
1294   HOWTO (R_PPC64_TLSLD,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLSLD",       /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TOCSAVE,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TOCSAVE",     /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   /* Computes the load module index of the load module that contains the
1323      definition of its TLS sym.  */
1324   HOWTO (R_PPC64_DTPMOD64,
1325          0,                     /* rightshift */
1326          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1327          64,                    /* bitsize */
1328          FALSE,                 /* pc_relative */
1329          0,                     /* bitpos */
1330          complain_overflow_dont, /* complain_on_overflow */
1331          ppc64_elf_unhandled_reloc, /* special_function */
1332          "R_PPC64_DTPMOD64",    /* name */
1333          FALSE,                 /* partial_inplace */
1334          0,                     /* src_mask */
1335          ONES (64),             /* dst_mask */
1336          FALSE),                /* pcrel_offset */
1337
1338   /* Computes a dtv-relative displacement, the difference between the value
1339      of sym+add and the base address of the thread-local storage block that
1340      contains the definition of sym, minus 0x8000.  */
1341   HOWTO (R_PPC64_DTPREL64,
1342          0,                     /* rightshift */
1343          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          64,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont, /* complain_on_overflow */
1348          ppc64_elf_unhandled_reloc, /* special_function */
1349          "R_PPC64_DTPREL64",    /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          ONES (64),             /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* A 16 bit dtprel reloc.  */
1356   HOWTO (R_PPC64_DTPREL16,
1357          0,                     /* rightshift */
1358          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          16,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_signed, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL16",    /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0xffff,                /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* Like DTPREL16, but no overflow.  */
1371   HOWTO (R_PPC64_DTPREL16_LO,
1372          0,                     /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16_LO", /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1386   HOWTO (R_PPC64_DTPREL16_HI,
1387          16,                    /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_signed, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_HI", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HA,
1402          16,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_signed, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HA", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HIGHER,
1417          32,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_dont, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HIGHER", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1432          32,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHERA", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1447          48,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHEST", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1461   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1462          48,                    /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_dont, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xffff,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16, but for insns with a DS field.  */
1476   HOWTO (R_PPC64_DTPREL16_DS,
1477          0,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_signed, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_DS", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xfffc,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Like DTPREL16_DS, but no overflow.  */
1491   HOWTO (R_PPC64_DTPREL16_LO_DS,
1492          0,                     /* rightshift */
1493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          16,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_dont, /* complain_on_overflow */
1498          ppc64_elf_unhandled_reloc, /* special_function */
1499          "R_PPC64_DTPREL16_LO_DS", /* name */
1500          FALSE,                 /* partial_inplace */
1501          0,                     /* src_mask */
1502          0xfffc,                /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   /* Computes a tp-relative displacement, the difference between the value of
1506      sym+add and the value of the thread pointer (r13).  */
1507   HOWTO (R_PPC64_TPREL64,
1508          0,                     /* rightshift */
1509          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          64,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_dont, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_TPREL64",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          ONES (64),             /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* A 16 bit tprel reloc.  */
1522   HOWTO (R_PPC64_TPREL16,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_signed, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL16",     /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Like TPREL16, but no overflow.  */
1537   HOWTO (R_PPC64_TPREL16_LO,
1538          0,                     /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16_LO",  /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1552   HOWTO (R_PPC64_TPREL16_HI,
1553          16,                    /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_signed, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_HI",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HA,
1568          16,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_signed, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HA",  /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HIGHER,
1583          32,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_dont, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HIGHER",      /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHERA,
1598          32,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHERA", /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHEST,
1613          48,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHEST", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1627   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1628          48,                    /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_dont, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_HIGHESTA", /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xffff,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16, but for insns with a DS field.  */
1642   HOWTO (R_PPC64_TPREL16_DS,
1643          0,                     /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_signed, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_DS",  /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xfffc,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Like TPREL16_DS, but no overflow.  */
1657   HOWTO (R_PPC64_TPREL16_LO_DS,
1658          0,                     /* rightshift */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1660          16,                    /* bitsize */
1661          FALSE,                 /* pc_relative */
1662          0,                     /* bitpos */
1663          complain_overflow_dont, /* complain_on_overflow */
1664          ppc64_elf_unhandled_reloc, /* special_function */
1665          "R_PPC64_TPREL16_LO_DS", /* name */
1666          FALSE,                 /* partial_inplace */
1667          0,                     /* src_mask */
1668          0xfffc,                /* dst_mask */
1669          FALSE),                /* pcrel_offset */
1670
1671   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1672      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1673      to the first entry relative to the TOC base (r2).  */
1674   HOWTO (R_PPC64_GOT_TLSGD16,
1675          0,                     /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_signed, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_GOT_TLSGD16", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like GOT_TLSGD16, but no overflow.  */
1689   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1690          0,                     /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16_LO", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1705          16,                    /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_signed, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_HI", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1719   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1720          16,                    /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          FALSE,                 /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_signed, /* complain_on_overflow */
1726          ppc64_elf_unhandled_reloc, /* special_function */
1727          "R_PPC64_GOT_TLSGD16_HA", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1734      with values (sym+add)@dtpmod and zero, and computes the offset to the
1735      first entry relative to the TOC base (r2).  */
1736   HOWTO (R_PPC64_GOT_TLSLD16,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_signed, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSLD16", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSLD16, but no overflow.  */
1751   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16_LO", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1767          16,                    /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_signed, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_HI", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1781   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1782          16,                    /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_signed, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSLD16_HA", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1796      the offset to the entry relative to the TOC base (r2).  */
1797   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1798          0,                     /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_signed, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_DTPREL16_DS", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xfffc,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_DTPREL16_DS, but no overflow.  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1813          0,                     /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_dont, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xfffc,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1828          16,                    /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_signed, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_HI", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xffff,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1842   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1843          16,                    /* rightshift */
1844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1845          16,                    /* bitsize */
1846          FALSE,                 /* pc_relative */
1847          0,                     /* bitpos */
1848          complain_overflow_signed, /* complain_on_overflow */
1849          ppc64_elf_unhandled_reloc, /* special_function */
1850          "R_PPC64_GOT_DTPREL16_HA", /* name */
1851          FALSE,                 /* partial_inplace */
1852          0,                     /* src_mask */
1853          0xffff,                /* dst_mask */
1854          FALSE),                /* pcrel_offset */
1855
1856   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1857      offset to the entry relative to the TOC base (r2).  */
1858   HOWTO (R_PPC64_GOT_TPREL16_DS,
1859          0,                     /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_signed, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_TPREL16_DS", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xfffc,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_TPREL16_DS, but no overflow.  */
1873   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1874          0,                     /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_dont, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xfffc,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_HI,
1889          16,                    /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_signed, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_HI", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xffff,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1903   HOWTO (R_PPC64_GOT_TPREL16_HA,
1904          16,                    /* rightshift */
1905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1906          16,                    /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_signed, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_GOT_TPREL16_HA", /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0xffff,                /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   HOWTO (R_PPC64_JMP_IREL,      /* type */
1918          0,                     /* rightshift */
1919          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1920          0,                     /* bitsize */
1921          FALSE,                 /* pc_relative */
1922          0,                     /* bitpos */
1923          complain_overflow_dont, /* complain_on_overflow */
1924          ppc64_elf_unhandled_reloc, /* special_function */
1925          "R_PPC64_JMP_IREL",    /* name */
1926          FALSE,                 /* partial_inplace */
1927          0,                     /* src_mask */
1928          0,                     /* dst_mask */
1929          FALSE),                /* pcrel_offset */
1930
1931   HOWTO (R_PPC64_IRELATIVE,     /* type */
1932          0,                     /* rightshift */
1933          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1934          64,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_dont, /* complain_on_overflow */
1938          bfd_elf_generic_reloc, /* special_function */
1939          "R_PPC64_IRELATIVE",   /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          ONES (64),             /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   /* A 16 bit relative relocation.  */
1946   HOWTO (R_PPC64_REL16,         /* type */
1947          0,                     /* rightshift */
1948          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1949          16,                    /* bitsize */
1950          TRUE,                  /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_signed, /* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_REL16",       /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          0xffff,                /* dst_mask */
1958          TRUE),                 /* pcrel_offset */
1959
1960   /* A 16 bit relative relocation without overflow.  */
1961   HOWTO (R_PPC64_REL16_LO,      /* type */
1962          0,                     /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont,/* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16_LO",    /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* The high order 16 bits of a relative address.  */
1976   HOWTO (R_PPC64_REL16_HI,      /* type */
1977          16,                    /* rightshift */
1978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1979          16,                    /* bitsize */
1980          TRUE,                  /* pc_relative */
1981          0,                     /* bitpos */
1982          complain_overflow_signed, /* complain_on_overflow */
1983          bfd_elf_generic_reloc, /* special_function */
1984          "R_PPC64_REL16_HI",    /* name */
1985          FALSE,                 /* partial_inplace */
1986          0,                     /* src_mask */
1987          0xffff,                /* dst_mask */
1988          TRUE),                 /* pcrel_offset */
1989
1990   /* The high order 16 bits of a relative address, plus 1 if the contents of
1991      the low 16 bits, treated as a signed number, is negative.  */
1992   HOWTO (R_PPC64_REL16_HA,      /* type */
1993          16,                    /* rightshift */
1994          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          16,                    /* bitsize */
1996          TRUE,                  /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_signed, /* complain_on_overflow */
1999          ppc64_elf_ha_reloc,    /* special_function */
2000          "R_PPC64_REL16_HA",    /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0xffff,                /* dst_mask */
2004          TRUE),                 /* pcrel_offset */
2005
2006   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2007   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2008          16,                    /* rightshift */
2009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          16,                    /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont, /* complain_on_overflow */
2014          bfd_elf_generic_reloc, /* special_function */
2015          "R_PPC64_ADDR16_HIGH", /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0xffff,                /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020
2021   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2022   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2023          16,                    /* rightshift */
2024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2025          16,                    /* bitsize */
2026          FALSE,                 /* pc_relative */
2027          0,                     /* bitpos */
2028          complain_overflow_dont, /* complain_on_overflow */
2029          ppc64_elf_ha_reloc,    /* special_function */
2030          "R_PPC64_ADDR16_HIGHA",        /* name */
2031          FALSE,                 /* partial_inplace */
2032          0,                     /* src_mask */
2033          0xffff,                /* dst_mask */
2034          FALSE),                /* pcrel_offset */
2035
2036   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2037   HOWTO (R_PPC64_DTPREL16_HIGH,
2038          16,                    /* rightshift */
2039          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2040          16,                    /* bitsize */
2041          FALSE,                 /* pc_relative */
2042          0,                     /* bitpos */
2043          complain_overflow_dont, /* complain_on_overflow */
2044          ppc64_elf_unhandled_reloc, /* special_function */
2045          "R_PPC64_DTPREL16_HIGH", /* name */
2046          FALSE,                 /* partial_inplace */
2047          0,                     /* src_mask */
2048          0xffff,                /* dst_mask */
2049          FALSE),                /* pcrel_offset */
2050
2051   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2052   HOWTO (R_PPC64_DTPREL16_HIGHA,
2053          16,                    /* rightshift */
2054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2055          16,                    /* bitsize */
2056          FALSE,                 /* pc_relative */
2057          0,                     /* bitpos */
2058          complain_overflow_dont, /* complain_on_overflow */
2059          ppc64_elf_unhandled_reloc, /* special_function */
2060          "R_PPC64_DTPREL16_HIGHA", /* name */
2061          FALSE,                 /* partial_inplace */
2062          0,                     /* src_mask */
2063          0xffff,                /* dst_mask */
2064          FALSE),                /* pcrel_offset */
2065
2066   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2067   HOWTO (R_PPC64_TPREL16_HIGH,
2068          16,                    /* rightshift */
2069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2070          16,                    /* bitsize */
2071          FALSE,                 /* pc_relative */
2072          0,                     /* bitpos */
2073          complain_overflow_dont, /* complain_on_overflow */
2074          ppc64_elf_unhandled_reloc, /* special_function */
2075          "R_PPC64_TPREL16_HIGH",        /* name */
2076          FALSE,                 /* partial_inplace */
2077          0,                     /* src_mask */
2078          0xffff,                /* dst_mask */
2079          FALSE),                /* pcrel_offset */
2080
2081   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2082   HOWTO (R_PPC64_TPREL16_HIGHA,
2083          16,                    /* rightshift */
2084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2085          16,                    /* bitsize */
2086          FALSE,                 /* pc_relative */
2087          0,                     /* bitpos */
2088          complain_overflow_dont, /* complain_on_overflow */
2089          ppc64_elf_unhandled_reloc, /* special_function */
2090          "R_PPC64_TPREL16_HIGHA",       /* name */
2091          FALSE,                 /* partial_inplace */
2092          0,                     /* src_mask */
2093          0xffff,                /* dst_mask */
2094          FALSE),                /* pcrel_offset */
2095
2096   /* Like ADDR64, but use local entry point of function.  */
2097   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2098          0,                     /* rightshift */
2099          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2100          64,                    /* bitsize */
2101          FALSE,                 /* pc_relative */
2102          0,                     /* bitpos */
2103          complain_overflow_dont, /* complain_on_overflow */
2104          bfd_elf_generic_reloc, /* special_function */
2105          "R_PPC64_ADDR64_LOCAL", /* name */
2106          FALSE,                 /* partial_inplace */
2107          0,                     /* src_mask */
2108          ONES (64),             /* dst_mask */
2109          FALSE),                /* pcrel_offset */
2110
2111   /* GNU extension to record C++ vtable hierarchy.  */
2112   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2113          0,                     /* rightshift */
2114          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2115          0,                     /* bitsize */
2116          FALSE,                 /* pc_relative */
2117          0,                     /* bitpos */
2118          complain_overflow_dont, /* complain_on_overflow */
2119          NULL,                  /* special_function */
2120          "R_PPC64_GNU_VTINHERIT", /* name */
2121          FALSE,                 /* partial_inplace */
2122          0,                     /* src_mask */
2123          0,                     /* dst_mask */
2124          FALSE),                /* pcrel_offset */
2125
2126   /* GNU extension to record C++ vtable member usage.  */
2127   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2128          0,                     /* rightshift */
2129          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2130          0,                     /* bitsize */
2131          FALSE,                 /* pc_relative */
2132          0,                     /* bitpos */
2133          complain_overflow_dont, /* complain_on_overflow */
2134          NULL,                  /* special_function */
2135          "R_PPC64_GNU_VTENTRY", /* name */
2136          FALSE,                 /* partial_inplace */
2137          0,                     /* src_mask */
2138          0,                     /* dst_mask */
2139          FALSE),                /* pcrel_offset */
2140 };
2141
2142 \f
2143 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2144    be done.  */
2145
2146 static void
2147 ppc_howto_init (void)
2148 {
2149   unsigned int i, type;
2150
2151   for (i = 0;
2152        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2153        i++)
2154     {
2155       type = ppc64_elf_howto_raw[i].type;
2156       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2157                           / sizeof (ppc64_elf_howto_table[0])));
2158       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2159     }
2160 }
2161
2162 static reloc_howto_type *
2163 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2164                              bfd_reloc_code_real_type code)
2165 {
2166   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2167
2168   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2169     /* Initialize howto table if needed.  */
2170     ppc_howto_init ();
2171
2172   switch (code)
2173     {
2174     default:
2175       return NULL;
2176
2177     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2178       break;
2179     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2180       break;
2181     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2182       break;
2183     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2184       break;
2185     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2186       break;
2187     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2188       break;
2189     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2190       break;
2191     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2192       break;
2193     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2194       break;
2195     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2196       break;
2197     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2198       break;
2199     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2200       break;
2201     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2202       break;
2203     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2204       break;
2205     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2206       break;
2207     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2208       break;
2209     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2210       break;
2211     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2212       break;
2213     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2214       break;
2215     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2216       break;
2217     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2218       break;
2219     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2220       break;
2221     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2222       break;
2223     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2224       break;
2225     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2226       break;
2227     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2228       break;
2229     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2230       break;
2231     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2232       break;
2233     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2234       break;
2235     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2236       break;
2237     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2238       break;
2239     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2240       break;
2241     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2242       break;
2243     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2244       break;
2245     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2246       break;
2247     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2248       break;
2249     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2250       break;
2251     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2252       break;
2253     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2254       break;
2255     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2256       break;
2257     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2258       break;
2259     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2260       break;
2261     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2262       break;
2263     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2264       break;
2265     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2266       break;
2267     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2268       break;
2269     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2270       break;
2271     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2272       break;
2273     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2274       break;
2275     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2276       break;
2277     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2278       break;
2279     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2280       break;
2281     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2282       break;
2283     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2284       break;
2285     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2286       break;
2287     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2288       break;
2289     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2290       break;
2291     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2292       break;
2293     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2294       break;
2295     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2296       break;
2297     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2298       break;
2299     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2300       break;
2301     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2302       break;
2303     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2304       break;
2305     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2306       break;
2307     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2308       break;
2309     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2310       break;
2311     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2312       break;
2313     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2314       break;
2315     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2318       break;
2319     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2320       break;
2321     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2322       break;
2323     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2324       break;
2325     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2326       break;
2327     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2328       break;
2329     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2330       break;
2331     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2332       break;
2333     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2334       break;
2335     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2336       break;
2337     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2338       break;
2339     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2340       break;
2341     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2342       break;
2343     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2344       break;
2345     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2346       break;
2347     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2348       break;
2349     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2350       break;
2351     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2352       break;
2353     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2356       break;
2357     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2358       break;
2359     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2360       break;
2361     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2362       break;
2363     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2364       break;
2365     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2368       break;
2369     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2370       break;
2371     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2372       break;
2373     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2374       break;
2375     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2376       break;
2377     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2378       break;
2379     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2382       break;
2383     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2384       break;
2385     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2386       break;
2387     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2388       break;
2389     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2390       break;
2391     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2392       break;
2393     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2394       break;
2395     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2396       break;
2397     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2398       break;
2399     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2400       break;
2401     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2402       break;
2403     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2404       break;
2405     }
2406
2407   return ppc64_elf_howto_table[r];
2408 };
2409
2410 static reloc_howto_type *
2411 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2412                              const char *r_name)
2413 {
2414   unsigned int i;
2415
2416   for (i = 0;
2417        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2418        i++)
2419     if (ppc64_elf_howto_raw[i].name != NULL
2420         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2421       return &ppc64_elf_howto_raw[i];
2422
2423   return NULL;
2424 }
2425
2426 /* Set the howto pointer for a PowerPC ELF reloc.  */
2427
2428 static void
2429 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2430                          Elf_Internal_Rela *dst)
2431 {
2432   unsigned int type;
2433
2434   /* Initialize howto table if needed.  */
2435   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2436     ppc_howto_init ();
2437
2438   type = ELF64_R_TYPE (dst->r_info);
2439   if (type >= (sizeof (ppc64_elf_howto_table)
2440                / sizeof (ppc64_elf_howto_table[0])))
2441     {
2442       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2443                              abfd, (int) type);
2444       type = R_PPC64_NONE;
2445     }
2446   cache_ptr->howto = ppc64_elf_howto_table[type];
2447 }
2448
2449 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2450
2451 static bfd_reloc_status_type
2452 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453                     void *data, asection *input_section,
2454                     bfd *output_bfd, char **error_message)
2455 {
2456   /* If this is a relocatable link (output_bfd test tells us), just
2457      call the generic function.  Any adjustment will be done at final
2458      link time.  */
2459   if (output_bfd != NULL)
2460     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2461                                   input_section, output_bfd, error_message);
2462
2463   /* Adjust the addend for sign extension of the low 16 bits.
2464      We won't actually be using the low 16 bits, so trashing them
2465      doesn't matter.  */
2466   reloc_entry->addend += 0x8000;
2467   return bfd_reloc_continue;
2468 }
2469
2470 static bfd_reloc_status_type
2471 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2472                         void *data, asection *input_section,
2473                         bfd *output_bfd, char **error_message)
2474 {
2475   if (output_bfd != NULL)
2476     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2477                                   input_section, output_bfd, error_message);
2478
2479   if (strcmp (symbol->section->name, ".opd") == 0
2480       && (symbol->section->owner->flags & DYNAMIC) == 0)
2481     {
2482       bfd_vma dest = opd_entry_value (symbol->section,
2483                                       symbol->value + reloc_entry->addend,
2484                                       NULL, NULL, FALSE);
2485       if (dest != (bfd_vma) -1)
2486         reloc_entry->addend = dest - (symbol->value
2487                                       + symbol->section->output_section->vma
2488                                       + symbol->section->output_offset);
2489     }
2490   return bfd_reloc_continue;
2491 }
2492
2493 static bfd_reloc_status_type
2494 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2495                          void *data, asection *input_section,
2496                          bfd *output_bfd, char **error_message)
2497 {
2498   long insn;
2499   enum elf_ppc64_reloc_type r_type;
2500   bfd_size_type octets;
2501   /* Assume 'at' branch hints.  */
2502   bfd_boolean is_isa_v2 = TRUE;
2503
2504   /* If this is a relocatable link (output_bfd test tells us), just
2505      call the generic function.  Any adjustment will be done at final
2506      link time.  */
2507   if (output_bfd != NULL)
2508     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2509                                   input_section, output_bfd, error_message);
2510
2511   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2512   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2513   insn &= ~(0x01 << 21);
2514   r_type = reloc_entry->howto->type;
2515   if (r_type == R_PPC64_ADDR14_BRTAKEN
2516       || r_type == R_PPC64_REL14_BRTAKEN)
2517     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2518
2519   if (is_isa_v2)
2520     {
2521       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2522          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2523          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2524       if ((insn & (0x14 << 21)) == (0x04 << 21))
2525         insn |= 0x02 << 21;
2526       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2527         insn |= 0x08 << 21;
2528       else
2529         goto out;
2530     }
2531   else
2532     {
2533       bfd_vma target = 0;
2534       bfd_vma from;
2535
2536       if (!bfd_is_com_section (symbol->section))
2537         target = symbol->value;
2538       target += symbol->section->output_section->vma;
2539       target += symbol->section->output_offset;
2540       target += reloc_entry->addend;
2541
2542       from = (reloc_entry->address
2543               + input_section->output_offset
2544               + input_section->output_section->vma);
2545
2546       /* Invert 'y' bit if not the default.  */
2547       if ((bfd_signed_vma) (target - from) < 0)
2548         insn ^= 0x01 << 21;
2549     }
2550   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2551  out:
2552   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2553                                  input_section, output_bfd, error_message);
2554 }
2555
2556 static bfd_reloc_status_type
2557 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2558                          void *data, asection *input_section,
2559                          bfd *output_bfd, char **error_message)
2560 {
2561   /* If this is a relocatable link (output_bfd test tells us), just
2562      call the generic function.  Any adjustment will be done at final
2563      link time.  */
2564   if (output_bfd != NULL)
2565     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2566                                   input_section, output_bfd, error_message);
2567
2568   /* Subtract the symbol section base address.  */
2569   reloc_entry->addend -= symbol->section->output_section->vma;
2570   return bfd_reloc_continue;
2571 }
2572
2573 static bfd_reloc_status_type
2574 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575                             void *data, asection *input_section,
2576                             bfd *output_bfd, char **error_message)
2577 {
2578   /* If this is a relocatable link (output_bfd test tells us), just
2579      call the generic function.  Any adjustment will be done at final
2580      link time.  */
2581   if (output_bfd != NULL)
2582     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2583                                   input_section, output_bfd, error_message);
2584
2585   /* Subtract the symbol section base address.  */
2586   reloc_entry->addend -= symbol->section->output_section->vma;
2587
2588   /* Adjust the addend for sign extension of the low 16 bits.  */
2589   reloc_entry->addend += 0x8000;
2590   return bfd_reloc_continue;
2591 }
2592
2593 static bfd_reloc_status_type
2594 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2595                      void *data, asection *input_section,
2596                      bfd *output_bfd, char **error_message)
2597 {
2598   bfd_vma TOCstart;
2599
2600   /* If this is a relocatable link (output_bfd test tells us), just
2601      call the generic function.  Any adjustment will be done at final
2602      link time.  */
2603   if (output_bfd != NULL)
2604     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2605                                   input_section, output_bfd, error_message);
2606
2607   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2608   if (TOCstart == 0)
2609     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2610
2611   /* Subtract the TOC base address.  */
2612   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2613   return bfd_reloc_continue;
2614 }
2615
2616 static bfd_reloc_status_type
2617 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2618                         void *data, asection *input_section,
2619                         bfd *output_bfd, char **error_message)
2620 {
2621   bfd_vma TOCstart;
2622
2623   /* If this is a relocatable link (output_bfd test tells us), just
2624      call the generic function.  Any adjustment will be done at final
2625      link time.  */
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2631   if (TOCstart == 0)
2632     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2633
2634   /* Subtract the TOC base address.  */
2635   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2636
2637   /* Adjust the addend for sign extension of the low 16 bits.  */
2638   reloc_entry->addend += 0x8000;
2639   return bfd_reloc_continue;
2640 }
2641
2642 static bfd_reloc_status_type
2643 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2644                        void *data, asection *input_section,
2645                        bfd *output_bfd, char **error_message)
2646 {
2647   bfd_vma TOCstart;
2648   bfd_size_type octets;
2649
2650   /* If this is a relocatable link (output_bfd test tells us), just
2651      call the generic function.  Any adjustment will be done at final
2652      link time.  */
2653   if (output_bfd != NULL)
2654     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2655                                   input_section, output_bfd, error_message);
2656
2657   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2658   if (TOCstart == 0)
2659     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2660
2661   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2662   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2663   return bfd_reloc_ok;
2664 }
2665
2666 static bfd_reloc_status_type
2667 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2668                            void *data, asection *input_section,
2669                            bfd *output_bfd, char **error_message)
2670 {
2671   /* If this is a relocatable link (output_bfd test tells us), just
2672      call the generic function.  Any adjustment will be done at final
2673      link time.  */
2674   if (output_bfd != NULL)
2675     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2676                                   input_section, output_bfd, error_message);
2677
2678   if (error_message != NULL)
2679     {
2680       static char buf[60];
2681       sprintf (buf, "generic linker can't handle %s",
2682                reloc_entry->howto->name);
2683       *error_message = buf;
2684     }
2685   return bfd_reloc_dangerous;
2686 }
2687
2688 /* Track GOT entries needed for a given symbol.  We might need more
2689    than one got entry per symbol.  */
2690 struct got_entry
2691 {
2692   struct got_entry *next;
2693
2694   /* The symbol addend that we'll be placing in the GOT.  */
2695   bfd_vma addend;
2696
2697   /* Unlike other ELF targets, we use separate GOT entries for the same
2698      symbol referenced from different input files.  This is to support
2699      automatic multiple TOC/GOT sections, where the TOC base can vary
2700      from one input file to another.  After partitioning into TOC groups
2701      we merge entries within the group.
2702
2703      Point to the BFD owning this GOT entry.  */
2704   bfd *owner;
2705
2706   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2707      TLS_TPREL or TLS_DTPREL for tls entries.  */
2708   unsigned char tls_type;
2709
2710   /* Non-zero if got.ent points to real entry.  */
2711   unsigned char is_indirect;
2712
2713   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718       struct got_entry *ent;
2719     } got;
2720 };
2721
2722 /* The same for PLT.  */
2723 struct plt_entry
2724 {
2725   struct plt_entry *next;
2726
2727   bfd_vma addend;
2728
2729   union
2730     {
2731       bfd_signed_vma refcount;
2732       bfd_vma offset;
2733     } plt;
2734 };
2735
2736 struct ppc64_elf_obj_tdata
2737 {
2738   struct elf_obj_tdata elf;
2739
2740   /* Shortcuts to dynamic linker sections.  */
2741   asection *got;
2742   asection *relgot;
2743
2744   /* Used during garbage collection.  We attach global symbols defined
2745      on removed .opd entries to this section so that the sym is removed.  */
2746   asection *deleted_section;
2747
2748   /* TLS local dynamic got entry handling.  Support for multiple GOT
2749      sections means we potentially need one of these for each input bfd.  */
2750   struct got_entry tlsld_got;
2751
2752   union {
2753     /* A copy of relocs before they are modified for --emit-relocs.  */
2754     Elf_Internal_Rela *relocs;
2755
2756     /* Section contents.  */
2757     bfd_byte *contents;
2758   } opd;
2759
2760   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2761      the reloc to be in the range -32768 to 32767.  */
2762   unsigned int has_small_toc_reloc : 1;
2763
2764   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2765      instruction not one we handle.  */
2766   unsigned int unexpected_toc_insn : 1;
2767 };
2768
2769 #define ppc64_elf_tdata(bfd) \
2770   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2771
2772 #define ppc64_tlsld_got(bfd) \
2773   (&ppc64_elf_tdata (bfd)->tlsld_got)
2774
2775 #define is_ppc64_elf(bfd) \
2776   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2777    && elf_object_id (bfd) == PPC64_ELF_DATA)
2778
2779 /* Override the generic function because we store some extras.  */
2780
2781 static bfd_boolean
2782 ppc64_elf_mkobject (bfd *abfd)
2783 {
2784   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2785                                   PPC64_ELF_DATA);
2786 }
2787
2788 /* Fix bad default arch selected for a 64 bit input bfd when the
2789    default is 32 bit.  */
2790
2791 static bfd_boolean
2792 ppc64_elf_object_p (bfd *abfd)
2793 {
2794   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2795     {
2796       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2797
2798       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2799         {
2800           /* Relies on arch after 32 bit default being 64 bit default.  */
2801           abfd->arch_info = abfd->arch_info->next;
2802           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2803         }
2804     }
2805   return TRUE;
2806 }
2807
2808 /* Support for core dump NOTE sections.  */
2809
2810 static bfd_boolean
2811 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2812 {
2813   size_t offset, size;
2814
2815   if (note->descsz != 504)
2816     return FALSE;
2817
2818   /* pr_cursig */
2819   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2820
2821   /* pr_pid */
2822   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2823
2824   /* pr_reg */
2825   offset = 112;
2826   size = 384;
2827
2828   /* Make a ".reg/999" section.  */
2829   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2830                                           size, note->descpos + offset);
2831 }
2832
2833 static bfd_boolean
2834 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2835 {
2836   if (note->descsz != 136)
2837     return FALSE;
2838
2839   elf_tdata (abfd)->core->pid
2840     = bfd_get_32 (abfd, note->descdata + 24);
2841   elf_tdata (abfd)->core->program
2842     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2843   elf_tdata (abfd)->core->command
2844     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2845
2846   return TRUE;
2847 }
2848
2849 static char *
2850 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2851                            ...)
2852 {
2853   switch (note_type)
2854     {
2855     default:
2856       return NULL;
2857
2858     case NT_PRPSINFO:
2859       {
2860         char data[136];
2861         va_list ap;
2862
2863         va_start (ap, note_type);
2864         memset (data, 0, sizeof (data));
2865         strncpy (data + 40, va_arg (ap, const char *), 16);
2866         strncpy (data + 56, va_arg (ap, const char *), 80);
2867         va_end (ap);
2868         return elfcore_write_note (abfd, buf, bufsiz,
2869                                    "CORE", note_type, data, sizeof (data));
2870       }
2871
2872     case NT_PRSTATUS:
2873       {
2874         char data[504];
2875         va_list ap;
2876         long pid;
2877         int cursig;
2878         const void *greg;
2879
2880         va_start (ap, note_type);
2881         memset (data, 0, 112);
2882         pid = va_arg (ap, long);
2883         bfd_put_32 (abfd, pid, data + 32);
2884         cursig = va_arg (ap, int);
2885         bfd_put_16 (abfd, cursig, data + 12);
2886         greg = va_arg (ap, const void *);
2887         memcpy (data + 112, greg, 384);
2888         memset (data + 496, 0, 8);
2889         va_end (ap);
2890         return elfcore_write_note (abfd, buf, bufsiz,
2891                                    "CORE", note_type, data, sizeof (data));
2892       }
2893     }
2894 }
2895
2896 /* Add extra PPC sections.  */
2897
2898 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2899 {
2900   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2901   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2902   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2903   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2906   { NULL,                     0,  0, 0,            0 }
2907 };
2908
2909 enum _ppc64_sec_type {
2910   sec_normal = 0,
2911   sec_opd = 1,
2912   sec_toc = 2
2913 };
2914
2915 struct _ppc64_elf_section_data
2916 {
2917   struct bfd_elf_section_data elf;
2918
2919   union
2920   {
2921     /* An array with one entry for each opd function descriptor.  */
2922     struct _opd_sec_data
2923     {
2924       /* Points to the function code section for local opd entries.  */
2925       asection **func_sec;
2926
2927       /* After editing .opd, adjust references to opd local syms.  */
2928       long *adjust;
2929     } opd;
2930
2931     /* An array for toc sections, indexed by offset/8.  */
2932     struct _toc_sec_data
2933     {
2934       /* Specifies the relocation symbol index used at a given toc offset.  */
2935       unsigned *symndx;
2936
2937       /* And the relocation addend.  */
2938       bfd_vma *add;
2939     } toc;
2940   } u;
2941
2942   enum _ppc64_sec_type sec_type:2;
2943
2944   /* Flag set when small branches are detected.  Used to
2945      select suitable defaults for the stub group size.  */
2946   unsigned int has_14bit_branch:1;
2947 };
2948
2949 #define ppc64_elf_section_data(sec) \
2950   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2951
2952 static bfd_boolean
2953 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2954 {
2955   if (!sec->used_by_bfd)
2956     {
2957       struct _ppc64_elf_section_data *sdata;
2958       bfd_size_type amt = sizeof (*sdata);
2959
2960       sdata = bfd_zalloc (abfd, amt);
2961       if (sdata == NULL)
2962         return FALSE;
2963       sec->used_by_bfd = sdata;
2964     }
2965
2966   return _bfd_elf_new_section_hook (abfd, sec);
2967 }
2968
2969 static struct _opd_sec_data *
2970 get_opd_info (asection * sec)
2971 {
2972   if (sec != NULL
2973       && ppc64_elf_section_data (sec) != NULL
2974       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2975     return &ppc64_elf_section_data (sec)->u.opd;
2976   return NULL;
2977 }
2978
2979 static inline int
2980 abiversion (bfd *abfd)
2981 {
2982   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2983 }
2984
2985 static inline void
2986 set_abiversion (bfd *abfd, int ver)
2987 {
2988   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2989   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2990 }
2991 \f
2992 /* Parameters for the qsort hook.  */
2993 static bfd_boolean synthetic_relocatable;
2994
2995 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2996
2997 static int
2998 compare_symbols (const void *ap, const void *bp)
2999 {
3000   const asymbol *a = * (const asymbol **) ap;
3001   const asymbol *b = * (const asymbol **) bp;
3002
3003   /* Section symbols first.  */
3004   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3005     return -1;
3006   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3007     return 1;
3008
3009   /* then .opd symbols.  */
3010   if (strcmp (a->section->name, ".opd") == 0
3011       && strcmp (b->section->name, ".opd") != 0)
3012     return -1;
3013   if (strcmp (a->section->name, ".opd") != 0
3014       && strcmp (b->section->name, ".opd") == 0)
3015     return 1;
3016
3017   /* then other code symbols.  */
3018   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3019       == (SEC_CODE | SEC_ALLOC)
3020       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3021          != (SEC_CODE | SEC_ALLOC))
3022     return -1;
3023
3024   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3025       != (SEC_CODE | SEC_ALLOC)
3026       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3027          == (SEC_CODE | SEC_ALLOC))
3028     return 1;
3029
3030   if (synthetic_relocatable)
3031     {
3032       if (a->section->id < b->section->id)
3033         return -1;
3034
3035       if (a->section->id > b->section->id)
3036         return 1;
3037     }
3038
3039   if (a->value + a->section->vma < b->value + b->section->vma)
3040     return -1;
3041
3042   if (a->value + a->section->vma > b->value + b->section->vma)
3043     return 1;
3044
3045   /* For syms with the same value, prefer strong dynamic global function
3046      syms over other syms.  */
3047   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3048     return -1;
3049
3050   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3051     return 1;
3052
3053   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3054     return -1;
3055
3056   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3057     return 1;
3058
3059   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3060     return -1;
3061
3062   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3063     return 1;
3064
3065   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3066     return -1;
3067
3068   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3069     return 1;
3070
3071   return 0;
3072 }
3073
3074 /* Search SYMS for a symbol of the given VALUE.  */
3075
3076 static asymbol *
3077 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3078 {
3079   long mid;
3080
3081   if (id == -1)
3082     {
3083       while (lo < hi)
3084         {
3085           mid = (lo + hi) >> 1;
3086           if (syms[mid]->value + syms[mid]->section->vma < value)
3087             lo = mid + 1;
3088           else if (syms[mid]->value + syms[mid]->section->vma > value)
3089             hi = mid;
3090           else
3091             return syms[mid];
3092         }
3093     }
3094   else
3095     {
3096       while (lo < hi)
3097         {
3098           mid = (lo + hi) >> 1;
3099           if (syms[mid]->section->id < id)
3100             lo = mid + 1;
3101           else if (syms[mid]->section->id > id)
3102             hi = mid;
3103           else if (syms[mid]->value < value)
3104             lo = mid + 1;
3105           else if (syms[mid]->value > value)
3106             hi = mid;
3107           else
3108             return syms[mid];
3109         }
3110     }
3111   return NULL;
3112 }
3113
3114 static bfd_boolean
3115 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3116 {
3117   bfd_vma vma = *(bfd_vma *) ptr;
3118   return ((section->flags & SEC_ALLOC) != 0
3119           && section->vma <= vma
3120           && vma < section->vma + section->size);
3121 }
3122
3123 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3124    entry syms.  Also generate @plt symbols for the glink branch table.  */
3125
3126 static long
3127 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3128                                 long static_count, asymbol **static_syms,
3129                                 long dyn_count, asymbol **dyn_syms,
3130                                 asymbol **ret)
3131 {
3132   asymbol *s;
3133   long i;
3134   long count;
3135   char *names;
3136   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3137   asection *opd = NULL;
3138   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3139   asymbol **syms;
3140   int abi = abiversion (abfd);
3141
3142   *ret = NULL;
3143
3144   if (abi < 2)
3145     {
3146       opd = bfd_get_section_by_name (abfd, ".opd");
3147       if (opd == NULL && abi == 1)
3148         return 0;
3149     }
3150
3151   symcount = static_count;
3152   if (!relocatable)
3153     symcount += dyn_count;
3154   if (symcount == 0)
3155     return 0;
3156
3157   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3158   if (syms == NULL)
3159     return -1;
3160
3161   if (!relocatable && static_count != 0 && dyn_count != 0)
3162     {
3163       /* Use both symbol tables.  */
3164       memcpy (syms, static_syms, static_count * sizeof (*syms));
3165       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3166     }
3167   else if (!relocatable && static_count == 0)
3168     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3169   else
3170     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3171
3172   synthetic_relocatable = relocatable;
3173   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3174
3175   if (!relocatable && symcount > 1)
3176     {
3177       long j;
3178       /* Trim duplicate syms, since we may have merged the normal and
3179          dynamic symbols.  Actually, we only care about syms that have
3180          different values, so trim any with the same value.  */
3181       for (i = 1, j = 1; i < symcount; ++i)
3182         if (syms[i - 1]->value + syms[i - 1]->section->vma
3183             != syms[i]->value + syms[i]->section->vma)
3184           syms[j++] = syms[i];
3185       symcount = j;
3186     }
3187
3188   i = 0;
3189   if (strcmp (syms[i]->section->name, ".opd") == 0)
3190     ++i;
3191   codesecsym = i;
3192
3193   for (; i < symcount; ++i)
3194     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195          != (SEC_CODE | SEC_ALLOC))
3196         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3197       break;
3198   codesecsymend = i;
3199
3200   for (; i < symcount; ++i)
3201     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3202       break;
3203   secsymend = i;
3204
3205   for (; i < symcount; ++i)
3206     if (strcmp (syms[i]->section->name, ".opd") != 0)
3207       break;
3208   opdsymend = i;
3209
3210   for (; i < symcount; ++i)
3211     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3212         != (SEC_CODE | SEC_ALLOC))
3213       break;
3214   symcount = i;
3215
3216   count = 0;
3217
3218   if (relocatable)
3219     {
3220       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3221       arelent *r;
3222       size_t size;
3223       long relcount;
3224
3225       if (opdsymend == secsymend)
3226         goto done;
3227
3228       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3229       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3230       if (relcount == 0)
3231         goto done;
3232
3233       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3234         {
3235           count = -1;
3236           goto done;
3237         }
3238
3239       size = 0;
3240       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3241         {
3242           asymbol *sym;
3243
3244           while (r < opd->relocation + relcount
3245                  && r->address < syms[i]->value + opd->vma)
3246             ++r;
3247
3248           if (r == opd->relocation + relcount)
3249             break;
3250
3251           if (r->address != syms[i]->value + opd->vma)
3252             continue;
3253
3254           if (r->howto->type != R_PPC64_ADDR64)
3255             continue;
3256
3257           sym = *r->sym_ptr_ptr;
3258           if (!sym_exists_at (syms, opdsymend, symcount,
3259                               sym->section->id, sym->value + r->addend))
3260             {
3261               ++count;
3262               size += sizeof (asymbol);
3263               size += strlen (syms[i]->name) + 2;
3264             }
3265         }
3266
3267       s = *ret = bfd_malloc (size);
3268       if (s == NULL)
3269         {
3270           count = -1;
3271           goto done;
3272         }
3273
3274       names = (char *) (s + count);
3275
3276       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3277         {
3278           asymbol *sym;
3279
3280           while (r < opd->relocation + relcount
3281                  && r->address < syms[i]->value + opd->vma)
3282             ++r;
3283
3284           if (r == opd->relocation + relcount)
3285             break;
3286
3287           if (r->address != syms[i]->value + opd->vma)
3288             continue;
3289
3290           if (r->howto->type != R_PPC64_ADDR64)
3291             continue;
3292
3293           sym = *r->sym_ptr_ptr;
3294           if (!sym_exists_at (syms, opdsymend, symcount,
3295                               sym->section->id, sym->value + r->addend))
3296             {
3297               size_t len;
3298
3299               *s = *syms[i];
3300               s->flags |= BSF_SYNTHETIC;
3301               s->section = sym->section;
3302               s->value = sym->value + r->addend;
3303               s->name = names;
3304               *names++ = '.';
3305               len = strlen (syms[i]->name);
3306               memcpy (names, syms[i]->name, len + 1);
3307               names += len + 1;
3308               /* Have udata.p point back to the original symbol this
3309                  synthetic symbol was derived from.  */
3310               s->udata.p = syms[i];
3311               s++;
3312             }
3313         }
3314     }
3315   else
3316     {
3317       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3318       bfd_byte *contents = NULL;
3319       size_t size;
3320       long plt_count = 0;
3321       bfd_vma glink_vma = 0, resolv_vma = 0;
3322       asection *dynamic, *glink = NULL, *relplt = NULL;
3323       arelent *p;
3324
3325       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3326         {
3327         free_contents_and_exit:
3328           if (contents)
3329             free (contents);
3330           count = -1;
3331           goto done;
3332         }
3333
3334       size = 0;
3335       for (i = secsymend; i < opdsymend; ++i)
3336         {
3337           bfd_vma ent;
3338
3339           /* Ignore bogus symbols.  */
3340           if (syms[i]->value > opd->size - 8)
3341             continue;
3342
3343           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3344           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3345             {
3346               ++count;
3347               size += sizeof (asymbol);
3348               size += strlen (syms[i]->name) + 2;
3349             }
3350         }
3351
3352       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3353       if (dyn_count != 0
3354           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3355         {
3356           bfd_byte *dynbuf, *extdyn, *extdynend;
3357           size_t extdynsize;
3358           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3359
3360           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3361             goto free_contents_and_exit;
3362
3363           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3364           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3365
3366           extdyn = dynbuf;
3367           extdynend = extdyn + dynamic->size;
3368           for (; extdyn < extdynend; extdyn += extdynsize)
3369             {
3370               Elf_Internal_Dyn dyn;
3371               (*swap_dyn_in) (abfd, extdyn, &dyn);
3372
3373               if (dyn.d_tag == DT_NULL)
3374                 break;
3375
3376               if (dyn.d_tag == DT_PPC64_GLINK)
3377                 {
3378                   /* The first glink stub starts at offset 32; see
3379                      comment in ppc64_elf_finish_dynamic_sections. */
3380                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3381                   /* The .glink section usually does not survive the final
3382                      link; search for the section (usually .text) where the
3383                      glink stubs now reside.  */
3384                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3385                                                 &glink_vma);
3386                   break;
3387                 }
3388             }
3389
3390           free (dynbuf);
3391         }
3392
3393       if (glink != NULL)
3394         {
3395           /* Determine __glink trampoline by reading the relative branch
3396              from the first glink stub.  */
3397           bfd_byte buf[4];
3398           unsigned int off = 0;
3399
3400           while (bfd_get_section_contents (abfd, glink, buf,
3401                                            glink_vma + off - glink->vma, 4))
3402             {
3403               unsigned int insn = bfd_get_32 (abfd, buf);
3404               insn ^= B_DOT;
3405               if ((insn & ~0x3fffffc) == 0)
3406                 {
3407                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3408                   break;
3409                 }
3410               off += 4;
3411               if (off > 4)
3412                 break;
3413             }
3414
3415           if (resolv_vma)
3416             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3417
3418           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3419           if (relplt != NULL)
3420             {
3421               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3422               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3423                 goto free_contents_and_exit;
3424
3425               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3426               size += plt_count * sizeof (asymbol);
3427
3428               p = relplt->relocation;
3429               for (i = 0; i < plt_count; i++, p++)
3430                 {
3431                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3432                   if (p->addend != 0)
3433                     size += sizeof ("+0x") - 1 + 16;
3434                 }
3435             }
3436         }
3437
3438       s = *ret = bfd_malloc (size);
3439       if (s == NULL)
3440         goto free_contents_and_exit;
3441
3442       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3443
3444       for (i = secsymend; i < opdsymend; ++i)
3445         {
3446           bfd_vma ent;
3447
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               long lo, hi;
3455               size_t len;
3456               asection *sec = abfd->sections;
3457
3458               *s = *syms[i];
3459               lo = codesecsym;
3460               hi = codesecsymend;
3461               while (lo < hi)
3462                 {
3463                   long mid = (lo + hi) >> 1;
3464                   if (syms[mid]->section->vma < ent)
3465                     lo = mid + 1;
3466                   else if (syms[mid]->section->vma > ent)
3467                     hi = mid;
3468                   else
3469                     {
3470                       sec = syms[mid]->section;
3471                       break;
3472                     }
3473                 }
3474
3475               if (lo >= hi && lo > codesecsym)
3476                 sec = syms[lo - 1]->section;
3477
3478               for (; sec != NULL; sec = sec->next)
3479                 {
3480                   if (sec->vma > ent)
3481                     break;
3482                   /* SEC_LOAD may not be set if SEC is from a separate debug
3483                      info file.  */
3484                   if ((sec->flags & SEC_ALLOC) == 0)
3485                     break;
3486                   if ((sec->flags & SEC_CODE) != 0)
3487                     s->section = sec;
3488                 }
3489               s->flags |= BSF_SYNTHETIC;
3490               s->value = ent - s->section->vma;
3491               s->name = names;
3492               *names++ = '.';
3493               len = strlen (syms[i]->name);
3494               memcpy (names, syms[i]->name, len + 1);
3495               names += len + 1;
3496               /* Have udata.p point back to the original symbol this
3497                  synthetic symbol was derived from.  */
3498               s->udata.p = syms[i];
3499               s++;
3500             }
3501         }
3502       free (contents);
3503
3504       if (glink != NULL && relplt != NULL)
3505         {
3506           if (resolv_vma)
3507             {
3508               /* Add a symbol for the main glink trampoline.  */
3509               memset (s, 0, sizeof *s);
3510               s->the_bfd = abfd;
3511               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3512               s->section = glink;
3513               s->value = resolv_vma - glink->vma;
3514               s->name = names;
3515               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3516               names += sizeof ("__glink_PLTresolve");
3517               s++;
3518               count++;
3519             }
3520
3521           /* FIXME: It would be very much nicer to put sym@plt on the
3522              stub rather than on the glink branch table entry.  The
3523              objdump disassembler would then use a sensible symbol
3524              name on plt calls.  The difficulty in doing so is
3525              a) finding the stubs, and,
3526              b) matching stubs against plt entries, and,
3527              c) there can be multiple stubs for a given plt entry.
3528
3529              Solving (a) could be done by code scanning, but older
3530              ppc64 binaries used different stubs to current code.
3531              (b) is the tricky one since you need to known the toc
3532              pointer for at least one function that uses a pic stub to
3533              be able to calculate the plt address referenced.
3534              (c) means gdb would need to set multiple breakpoints (or
3535              find the glink branch itself) when setting breakpoints
3536              for pending shared library loads.  */
3537           p = relplt->relocation;
3538           for (i = 0; i < plt_count; i++, p++)
3539             {
3540               size_t len;
3541
3542               *s = **p->sym_ptr_ptr;
3543               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3544                  we are defining a symbol, ensure one of them is set.  */
3545               if ((s->flags & BSF_LOCAL) == 0)
3546                 s->flags |= BSF_GLOBAL;
3547               s->flags |= BSF_SYNTHETIC;
3548               s->section = glink;
3549               s->value = glink_vma - glink->vma;
3550               s->name = names;
3551               s->udata.p = NULL;
3552               len = strlen ((*p->sym_ptr_ptr)->name);
3553               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3554               names += len;
3555               if (p->addend != 0)
3556                 {
3557                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3558                   names += sizeof ("+0x") - 1;
3559                   bfd_sprintf_vma (abfd, names, p->addend);
3560                   names += strlen (names);
3561                 }
3562               memcpy (names, "@plt", sizeof ("@plt"));
3563               names += sizeof ("@plt");
3564               s++;
3565               if (abi < 2)
3566                 {
3567                   glink_vma += 8;
3568                   if (i >= 0x8000)
3569                     glink_vma += 4;
3570                 }
3571               else
3572                 glink_vma += 4;
3573             }
3574           count += plt_count;
3575         }
3576     }
3577
3578  done:
3579   free (syms);
3580   return count;
3581 }
3582 \f
3583 /* The following functions are specific to the ELF linker, while
3584    functions above are used generally.  Those named ppc64_elf_* are
3585    called by the main ELF linker code.  They appear in this file more
3586    or less in the order in which they are called.  eg.
3587    ppc64_elf_check_relocs is called early in the link process,
3588    ppc64_elf_finish_dynamic_sections is one of the last functions
3589    called.
3590
3591    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3592    functions have both a function code symbol and a function descriptor
3593    symbol.  A call to foo in a relocatable object file looks like:
3594
3595    .            .text
3596    .    x:
3597    .            bl      .foo
3598    .            nop
3599
3600    The function definition in another object file might be:
3601
3602    .            .section .opd
3603    .    foo:    .quad   .foo
3604    .            .quad   .TOC.@tocbase
3605    .            .quad   0
3606    .
3607    .            .text
3608    .    .foo:   blr
3609
3610    When the linker resolves the call during a static link, the branch
3611    unsurprisingly just goes to .foo and the .opd information is unused.
3612    If the function definition is in a shared library, things are a little
3613    different:  The call goes via a plt call stub, the opd information gets
3614    copied to the plt, and the linker patches the nop.
3615
3616    .    x:
3617    .            bl      .foo_stub
3618    .            ld      2,40(1)
3619    .
3620    .
3621    .    .foo_stub:
3622    .            std     2,40(1)                 # in practice, the call stub
3623    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3624    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3625    .            ld      12,0(11)
3626    .            ld      2,8(11)
3627    .            mtctr   12
3628    .            ld      11,16(11)
3629    .            bctr
3630    .
3631    .            .section .plt
3632    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3633
3634    The "reloc ()" notation is supposed to indicate that the linker emits
3635    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3636    copying.
3637
3638    What are the difficulties here?  Well, firstly, the relocations
3639    examined by the linker in check_relocs are against the function code
3640    sym .foo, while the dynamic relocation in the plt is emitted against
3641    the function descriptor symbol, foo.  Somewhere along the line, we need
3642    to carefully copy dynamic link information from one symbol to the other.
3643    Secondly, the generic part of the elf linker will make .foo a dynamic
3644    symbol as is normal for most other backends.  We need foo dynamic
3645    instead, at least for an application final link.  However, when
3646    creating a shared library containing foo, we need to have both symbols
3647    dynamic so that references to .foo are satisfied during the early
3648    stages of linking.  Otherwise the linker might decide to pull in a
3649    definition from some other object, eg. a static library.
3650
3651    Update: As of August 2004, we support a new convention.  Function
3652    calls may use the function descriptor symbol, ie. "bl foo".  This
3653    behaves exactly as "bl .foo".  */
3654
3655 /* Of those relocs that might be copied as dynamic relocs, this function
3656    selects those that must be copied when linking a shared library,
3657    even when the symbol is local.  */
3658
3659 static int
3660 must_be_dyn_reloc (struct bfd_link_info *info,
3661                    enum elf_ppc64_reloc_type r_type)
3662 {
3663   switch (r_type)
3664     {
3665     default:
3666       return 1;
3667
3668     case R_PPC64_REL32:
3669     case R_PPC64_REL64:
3670     case R_PPC64_REL30:
3671       return 0;
3672
3673     case R_PPC64_TPREL16:
3674     case R_PPC64_TPREL16_LO:
3675     case R_PPC64_TPREL16_HI:
3676     case R_PPC64_TPREL16_HA:
3677     case R_PPC64_TPREL16_DS:
3678     case R_PPC64_TPREL16_LO_DS:
3679     case R_PPC64_TPREL16_HIGH:
3680     case R_PPC64_TPREL16_HIGHA:
3681     case R_PPC64_TPREL16_HIGHER:
3682     case R_PPC64_TPREL16_HIGHERA:
3683     case R_PPC64_TPREL16_HIGHEST:
3684     case R_PPC64_TPREL16_HIGHESTA:
3685     case R_PPC64_TPREL64:
3686       return !info->executable;
3687     }
3688 }
3689
3690 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3691    copying dynamic variables from a shared lib into an app's dynbss
3692    section, and instead use a dynamic relocation to point into the
3693    shared lib.  With code that gcc generates, it's vital that this be
3694    enabled;  In the PowerPC64 ABI, the address of a function is actually
3695    the address of a function descriptor, which resides in the .opd
3696    section.  gcc uses the descriptor directly rather than going via the
3697    GOT as some other ABI's do, which means that initialized function
3698    pointers must reference the descriptor.  Thus, a function pointer
3699    initialized to the address of a function in a shared library will
3700    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3701    redefines the function descriptor symbol to point to the copy.  This
3702    presents a problem as a plt entry for that function is also
3703    initialized from the function descriptor symbol and the copy reloc
3704    may not be initialized first.  */
3705 #define ELIMINATE_COPY_RELOCS 1
3706
3707 /* Section name for stubs is the associated section name plus this
3708    string.  */
3709 #define STUB_SUFFIX ".stub"
3710
3711 /* Linker stubs.
3712    ppc_stub_long_branch:
3713    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3714    destination, but a 24 bit branch in a stub section will reach.
3715    .    b       dest
3716
3717    ppc_stub_plt_branch:
3718    Similar to the above, but a 24 bit branch in the stub section won't
3719    reach its destination.
3720    .    addis   %r11,%r2,xxx@toc@ha
3721    .    ld      %r12,xxx@toc@l(%r11)
3722    .    mtctr   %r12
3723    .    bctr
3724
3725    ppc_stub_plt_call:
3726    Used to call a function in a shared library.  If it so happens that
3727    the plt entry referenced crosses a 64k boundary, then an extra
3728    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3729    .    std     %r2,40(%r1)
3730    .    addis   %r11,%r2,xxx@toc@ha
3731    .    ld      %r12,xxx+0@toc@l(%r11)
3732    .    mtctr   %r12
3733    .    ld      %r2,xxx+8@toc@l(%r11)
3734    .    ld      %r11,xxx+16@toc@l(%r11)
3735    .    bctr
3736
3737    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3738    code to adjust the value and save r2 to support multiple toc sections.
3739    A ppc_stub_long_branch with an r2 offset looks like:
3740    .    std     %r2,40(%r1)
3741    .    addis   %r2,%r2,off@ha
3742    .    addi    %r2,%r2,off@l
3743    .    b       dest
3744
3745    A ppc_stub_plt_branch with an r2 offset looks like:
3746    .    std     %r2,40(%r1)
3747    .    addis   %r11,%r2,xxx@toc@ha
3748    .    ld      %r12,xxx@toc@l(%r11)
3749    .    addis   %r2,%r2,off@ha
3750    .    addi    %r2,%r2,off@l
3751    .    mtctr   %r12
3752    .    bctr
3753
3754    In cases where the "addis" instruction would add zero, the "addis" is
3755    omitted and following instructions modified slightly in some cases.
3756 */
3757
3758 enum ppc_stub_type {
3759   ppc_stub_none,
3760   ppc_stub_long_branch,
3761   ppc_stub_long_branch_r2off,
3762   ppc_stub_plt_branch,
3763   ppc_stub_plt_branch_r2off,
3764   ppc_stub_plt_call,
3765   ppc_stub_plt_call_r2save
3766 };
3767
3768 struct ppc_stub_hash_entry {
3769
3770   /* Base hash table entry structure.  */
3771   struct bfd_hash_entry root;
3772
3773   enum ppc_stub_type stub_type;
3774
3775   /* The stub section.  */
3776   asection *stub_sec;
3777
3778   /* Offset within stub_sec of the beginning of this stub.  */
3779   bfd_vma stub_offset;
3780
3781   /* Given the symbol's value and its section we can determine its final
3782      value when building the stubs (so the stub knows where to jump.  */
3783   bfd_vma target_value;
3784   asection *target_section;
3785
3786   /* The symbol table entry, if any, that this was derived from.  */
3787   struct ppc_link_hash_entry *h;
3788   struct plt_entry *plt_ent;
3789
3790   /* Where this stub is being called from, or, in the case of combined
3791      stub sections, the first input section in the group.  */
3792   asection *id_sec;
3793
3794   /* Symbol st_other.  */
3795   unsigned char other;
3796 };
3797
3798 struct ppc_branch_hash_entry {
3799
3800   /* Base hash table entry structure.  */
3801   struct bfd_hash_entry root;
3802
3803   /* Offset within branch lookup table.  */
3804   unsigned int offset;
3805
3806   /* Generation marker.  */
3807   unsigned int iter;
3808 };
3809
3810 /* Used to track dynamic relocations for local symbols.  */
3811 struct ppc_dyn_relocs
3812 {
3813   struct ppc_dyn_relocs *next;
3814
3815   /* The input section of the reloc.  */
3816   asection *sec;
3817
3818   /* Total number of relocs copied for the input section.  */
3819   unsigned int count : 31;
3820
3821   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3822   unsigned int ifunc : 1;
3823 };
3824
3825 struct ppc_link_hash_entry
3826 {
3827   struct elf_link_hash_entry elf;
3828
3829   union {
3830     /* A pointer to the most recently used stub hash entry against this
3831        symbol.  */
3832     struct ppc_stub_hash_entry *stub_cache;
3833
3834     /* A pointer to the next symbol starting with a '.'  */
3835     struct ppc_link_hash_entry *next_dot_sym;
3836   } u;
3837
3838   /* Track dynamic relocs copied for this symbol.  */
3839   struct elf_dyn_relocs *dyn_relocs;
3840
3841   /* Link between function code and descriptor symbols.  */
3842   struct ppc_link_hash_entry *oh;
3843
3844   /* Flag function code and descriptor symbols.  */
3845   unsigned int is_func:1;
3846   unsigned int is_func_descriptor:1;
3847   unsigned int fake:1;
3848
3849   /* Whether global opd/toc sym has been adjusted or not.
3850      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3851      should be set for all globals defined in any opd/toc section.  */
3852   unsigned int adjust_done:1;
3853
3854   /* Set if we twiddled this symbol to weak at some stage.  */
3855   unsigned int was_undefined:1;
3856
3857   /* Contexts in which symbol is used in the GOT (or TOC).
3858      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3859      corresponding relocs are encountered during check_relocs.
3860      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3861      indicate the corresponding GOT entry type is not needed.
3862      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3863      a TPREL one.  We use a separate flag rather than setting TPREL
3864      just for convenience in distinguishing the two cases.  */
3865 #define TLS_GD           1      /* GD reloc. */
3866 #define TLS_LD           2      /* LD reloc. */
3867 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3868 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3869 #define TLS_TLS         16      /* Any TLS reloc.  */
3870 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3871 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3872 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3873   unsigned char tls_mask;
3874 };
3875
3876 /* ppc64 ELF linker hash table.  */
3877
3878 struct ppc_link_hash_table
3879 {
3880   struct elf_link_hash_table elf;
3881
3882   /* The stub hash table.  */
3883   struct bfd_hash_table stub_hash_table;
3884
3885   /* Another hash table for plt_branch stubs.  */
3886   struct bfd_hash_table branch_hash_table;
3887
3888   /* Hash table for function prologue tocsave.  */
3889   htab_t tocsave_htab;
3890
3891   /* Various options and other info passed from the linker.  */
3892   struct ppc64_elf_params *params;
3893
3894   /* Array to keep track of which stub sections have been created, and
3895      information on stub grouping.  */
3896   struct map_stub {
3897     /* This is the section to which stubs in the group will be attached.  */
3898     asection *link_sec;
3899     /* The stub section.  */
3900     asection *stub_sec;
3901     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3902     bfd_vma toc_off;
3903   } *stub_group;
3904
3905   /* Temp used when calculating TOC pointers.  */
3906   bfd_vma toc_curr;
3907   bfd *toc_bfd;
3908   asection *toc_first_sec;
3909
3910   /* Highest input section id.  */
3911   int top_id;
3912
3913   /* Highest output section index.  */
3914   int top_index;
3915
3916   /* Used when adding symbols.  */
3917   struct ppc_link_hash_entry *dot_syms;
3918
3919   /* List of input sections for each output section.  */
3920   asection **input_list;
3921
3922   /* Shortcuts to get to dynamic linker sections.  */
3923   asection *dynbss;
3924   asection *relbss;
3925   asection *glink;
3926   asection *sfpr;
3927   asection *brlt;
3928   asection *relbrlt;
3929   asection *glink_eh_frame;
3930
3931   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3932   struct ppc_link_hash_entry *tls_get_addr;
3933   struct ppc_link_hash_entry *tls_get_addr_fd;
3934
3935   /* The size of reliplt used by got entry relocs.  */
3936   bfd_size_type got_reli_size;
3937
3938   /* Statistics.  */
3939   unsigned long stub_count[ppc_stub_plt_call_r2save];
3940
3941   /* Number of stubs against global syms.  */
3942   unsigned long stub_globals;
3943
3944   /* Set if we're linking code with function descriptors.  */
3945   unsigned int opd_abi:1;
3946
3947   /* Support for multiple toc sections.  */
3948   unsigned int do_multi_toc:1;
3949   unsigned int multi_toc_needed:1;
3950   unsigned int second_toc_pass:1;
3951   unsigned int do_toc_opt:1;
3952
3953   /* Set on error.  */
3954   unsigned int stub_error:1;
3955
3956   /* Temp used by ppc64_elf_before_check_relocs.  */
3957   unsigned int twiddled_syms:1;
3958
3959   /* Incremented every time we size stubs.  */
3960   unsigned int stub_iteration;
3961
3962   /* Small local sym cache.  */
3963   struct sym_cache sym_cache;
3964 };
3965
3966 /* Rename some of the generic section flags to better document how they
3967    are used here.  */
3968
3969 /* Nonzero if this section has TLS related relocations.  */
3970 #define has_tls_reloc sec_flg0
3971
3972 /* Nonzero if this section has a call to __tls_get_addr.  */
3973 #define has_tls_get_addr_call sec_flg1
3974
3975 /* Nonzero if this section has any toc or got relocs.  */
3976 #define has_toc_reloc sec_flg2
3977
3978 /* Nonzero if this section has a call to another section that uses
3979    the toc or got.  */
3980 #define makes_toc_func_call sec_flg3
3981
3982 /* Recursion protection when determining above flag.  */
3983 #define call_check_in_progress sec_flg4
3984 #define call_check_done sec_flg5
3985
3986 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3987
3988 #define ppc_hash_table(p) \
3989   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3990   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3991
3992 #define ppc_stub_hash_lookup(table, string, create, copy) \
3993   ((struct ppc_stub_hash_entry *) \
3994    bfd_hash_lookup ((table), (string), (create), (copy)))
3995
3996 #define ppc_branch_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_branch_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 /* Create an entry in the stub hash table.  */
4001
4002 static struct bfd_hash_entry *
4003 stub_hash_newfunc (struct bfd_hash_entry *entry,
4004                    struct bfd_hash_table *table,
4005                    const char *string)
4006 {
4007   /* Allocate the structure if it has not already been allocated by a
4008      subclass.  */
4009   if (entry == NULL)
4010     {
4011       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4012       if (entry == NULL)
4013         return entry;
4014     }
4015
4016   /* Call the allocation method of the superclass.  */
4017   entry = bfd_hash_newfunc (entry, table, string);
4018   if (entry != NULL)
4019     {
4020       struct ppc_stub_hash_entry *eh;
4021
4022       /* Initialize the local fields.  */
4023       eh = (struct ppc_stub_hash_entry *) entry;
4024       eh->stub_type = ppc_stub_none;
4025       eh->stub_sec = NULL;
4026       eh->stub_offset = 0;
4027       eh->target_value = 0;
4028       eh->target_section = NULL;
4029       eh->h = NULL;
4030       eh->plt_ent = NULL;
4031       eh->id_sec = NULL;
4032       eh->other = 0;
4033     }
4034
4035   return entry;
4036 }
4037
4038 /* Create an entry in the branch hash table.  */
4039
4040 static struct bfd_hash_entry *
4041 branch_hash_newfunc (struct bfd_hash_entry *entry,
4042                      struct bfd_hash_table *table,
4043                      const char *string)
4044 {
4045   /* Allocate the structure if it has not already been allocated by a
4046      subclass.  */
4047   if (entry == NULL)
4048     {
4049       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4050       if (entry == NULL)
4051         return entry;
4052     }
4053
4054   /* Call the allocation method of the superclass.  */
4055   entry = bfd_hash_newfunc (entry, table, string);
4056   if (entry != NULL)
4057     {
4058       struct ppc_branch_hash_entry *eh;
4059
4060       /* Initialize the local fields.  */
4061       eh = (struct ppc_branch_hash_entry *) entry;
4062       eh->offset = 0;
4063       eh->iter = 0;
4064     }
4065
4066   return entry;
4067 }
4068
4069 /* Create an entry in a ppc64 ELF linker hash table.  */
4070
4071 static struct bfd_hash_entry *
4072 link_hash_newfunc (struct bfd_hash_entry *entry,
4073                    struct bfd_hash_table *table,
4074                    const char *string)
4075 {
4076   /* Allocate the structure if it has not already been allocated by a
4077      subclass.  */
4078   if (entry == NULL)
4079     {
4080       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4081       if (entry == NULL)
4082         return entry;
4083     }
4084
4085   /* Call the allocation method of the superclass.  */
4086   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4087   if (entry != NULL)
4088     {
4089       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4090
4091       memset (&eh->u.stub_cache, 0,
4092               (sizeof (struct ppc_link_hash_entry)
4093                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4094
4095       /* When making function calls, old ABI code references function entry
4096          points (dot symbols), while new ABI code references the function
4097          descriptor symbol.  We need to make any combination of reference and
4098          definition work together, without breaking archive linking.
4099
4100          For a defined function "foo" and an undefined call to "bar":
4101          An old object defines "foo" and ".foo", references ".bar" (possibly
4102          "bar" too).
4103          A new object defines "foo" and references "bar".
4104
4105          A new object thus has no problem with its undefined symbols being
4106          satisfied by definitions in an old object.  On the other hand, the
4107          old object won't have ".bar" satisfied by a new object.
4108
4109          Keep a list of newly added dot-symbols.  */
4110
4111       if (string[0] == '.')
4112         {
4113           struct ppc_link_hash_table *htab;
4114
4115           htab = (struct ppc_link_hash_table *) table;
4116           eh->u.next_dot_sym = htab->dot_syms;
4117           htab->dot_syms = eh;
4118         }
4119     }
4120
4121   return entry;
4122 }
4123
4124 struct tocsave_entry {
4125   asection *sec;
4126   bfd_vma offset;
4127 };
4128
4129 static hashval_t
4130 tocsave_htab_hash (const void *p)
4131 {
4132   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4133   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4134 }
4135
4136 static int
4137 tocsave_htab_eq (const void *p1, const void *p2)
4138 {
4139   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4140   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4141   return e1->sec == e2->sec && e1->offset == e2->offset;
4142 }
4143
4144 /* Destroy a ppc64 ELF linker hash table.  */
4145
4146 static void
4147 ppc64_elf_link_hash_table_free (bfd *obfd)
4148 {
4149   struct ppc_link_hash_table *htab;
4150
4151   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4152   if (htab->tocsave_htab)
4153     htab_delete (htab->tocsave_htab);
4154   bfd_hash_table_free (&htab->branch_hash_table);
4155   bfd_hash_table_free (&htab->stub_hash_table);
4156   _bfd_elf_link_hash_table_free (obfd);
4157 }
4158
4159 /* Create a ppc64 ELF linker hash table.  */
4160
4161 static struct bfd_link_hash_table *
4162 ppc64_elf_link_hash_table_create (bfd *abfd)
4163 {
4164   struct ppc_link_hash_table *htab;
4165   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4166
4167   htab = bfd_zmalloc (amt);
4168   if (htab == NULL)
4169     return NULL;
4170
4171   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4172                                       sizeof (struct ppc_link_hash_entry),
4173                                       PPC64_ELF_DATA))
4174     {
4175       free (htab);
4176       return NULL;
4177     }
4178
4179   /* Init the stub hash table too.  */
4180   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4181                             sizeof (struct ppc_stub_hash_entry)))
4182     {
4183       _bfd_elf_link_hash_table_free (abfd);
4184       return NULL;
4185     }
4186
4187   /* And the branch hash table.  */
4188   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4189                             sizeof (struct ppc_branch_hash_entry)))
4190     {
4191       bfd_hash_table_free (&htab->stub_hash_table);
4192       _bfd_elf_link_hash_table_free (abfd);
4193       return NULL;
4194     }
4195
4196   htab->tocsave_htab = htab_try_create (1024,
4197                                         tocsave_htab_hash,
4198                                         tocsave_htab_eq,
4199                                         NULL);
4200   if (htab->tocsave_htab == NULL)
4201     {
4202       ppc64_elf_link_hash_table_free (abfd);
4203       return NULL;
4204     }
4205   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4206
4207   /* Initializing two fields of the union is just cosmetic.  We really
4208      only care about glist, but when compiled on a 32-bit host the
4209      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4210      debugger inspection of these fields look nicer.  */
4211   htab->elf.init_got_refcount.refcount = 0;
4212   htab->elf.init_got_refcount.glist = NULL;
4213   htab->elf.init_plt_refcount.refcount = 0;
4214   htab->elf.init_plt_refcount.glist = NULL;
4215   htab->elf.init_got_offset.offset = 0;
4216   htab->elf.init_got_offset.glist = NULL;
4217   htab->elf.init_plt_offset.offset = 0;
4218   htab->elf.init_plt_offset.glist = NULL;
4219
4220   return &htab->elf.root;
4221 }
4222
4223 /* Create sections for linker generated code.  */
4224
4225 static bfd_boolean
4226 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4227 {
4228   struct ppc_link_hash_table *htab;
4229   flagword flags;
4230
4231   htab = ppc_hash_table (info);
4232
4233   /* Create .sfpr for code to save and restore fp regs.  */
4234   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4235            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4236   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4237                                                    flags);
4238   if (htab->sfpr == NULL
4239       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4240     return FALSE;
4241
4242   /* Create .glink for lazy dynamic linking support.  */
4243   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4244                                                     flags);
4245   if (htab->glink == NULL
4246       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4247     return FALSE;
4248
4249   if (!info->no_ld_generated_unwind_info)
4250     {
4251       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4252                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4253       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4254                                                                  ".eh_frame",
4255                                                                  flags);
4256       if (htab->glink_eh_frame == NULL
4257           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4258         return FALSE;
4259     }
4260
4261   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4262   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4263   if (htab->elf.iplt == NULL
4264       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4265     return FALSE;
4266
4267   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4268            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4269   htab->elf.irelplt
4270     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4271   if (htab->elf.irelplt == NULL
4272       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4273     return FALSE;
4274
4275   /* Create branch lookup table for plt_branch stubs.  */
4276   flags = (SEC_ALLOC | SEC_LOAD
4277            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4278   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4279                                                    flags);
4280   if (htab->brlt == NULL
4281       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4282     return FALSE;
4283
4284   if (!info->shared)
4285     return TRUE;
4286
4287   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4288            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4289   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4290                                                       ".rela.branch_lt",
4291                                                       flags);
4292   if (htab->relbrlt == NULL
4293       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4294     return FALSE;
4295
4296   return TRUE;
4297 }
4298
4299 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4300
4301 bfd_boolean
4302 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4303                          struct ppc64_elf_params *params)
4304 {
4305   struct ppc_link_hash_table *htab;
4306
4307   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4308
4309 /* Always hook our dynamic sections into the first bfd, which is the
4310    linker created stub bfd.  This ensures that the GOT header is at
4311    the start of the output TOC section.  */
4312   htab = ppc_hash_table (info);
4313   if (htab == NULL)
4314     return FALSE;
4315   htab->elf.dynobj = params->stub_bfd;
4316   htab->params = params;
4317
4318   if (info->relocatable)
4319     return TRUE;
4320
4321   return create_linkage_sections (htab->elf.dynobj, info);
4322 }
4323
4324 /* Build a name for an entry in the stub hash table.  */
4325
4326 static char *
4327 ppc_stub_name (const asection *input_section,
4328                const asection *sym_sec,
4329                const struct ppc_link_hash_entry *h,
4330                const Elf_Internal_Rela *rel)
4331 {
4332   char *stub_name;
4333   ssize_t len;
4334
4335   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4336      offsets from a sym as a branch target?  In fact, we could
4337      probably assume the addend is always zero.  */
4338   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4339
4340   if (h)
4341     {
4342       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4343       stub_name = bfd_malloc (len);
4344       if (stub_name == NULL)
4345         return stub_name;
4346
4347       len = sprintf (stub_name, "%08x.%s+%x",
4348                      input_section->id & 0xffffffff,
4349                      h->elf.root.root.string,
4350                      (int) rel->r_addend & 0xffffffff);
4351     }
4352   else
4353     {
4354       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4355       stub_name = bfd_malloc (len);
4356       if (stub_name == NULL)
4357         return stub_name;
4358
4359       len = sprintf (stub_name, "%08x.%x:%x+%x",
4360                      input_section->id & 0xffffffff,
4361                      sym_sec->id & 0xffffffff,
4362                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4363                      (int) rel->r_addend & 0xffffffff);
4364     }
4365   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4366     stub_name[len - 2] = 0;
4367   return stub_name;
4368 }
4369
4370 /* Look up an entry in the stub hash.  Stub entries are cached because
4371    creating the stub name takes a bit of time.  */
4372
4373 static struct ppc_stub_hash_entry *
4374 ppc_get_stub_entry (const asection *input_section,
4375                     const asection *sym_sec,
4376                     struct ppc_link_hash_entry *h,
4377                     const Elf_Internal_Rela *rel,
4378                     struct ppc_link_hash_table *htab)
4379 {
4380   struct ppc_stub_hash_entry *stub_entry;
4381   const asection *id_sec;
4382
4383   /* If this input section is part of a group of sections sharing one
4384      stub section, then use the id of the first section in the group.
4385      Stub names need to include a section id, as there may well be
4386      more than one stub used to reach say, printf, and we need to
4387      distinguish between them.  */
4388   id_sec = htab->stub_group[input_section->id].link_sec;
4389
4390   if (h != NULL && h->u.stub_cache != NULL
4391       && h->u.stub_cache->h == h
4392       && h->u.stub_cache->id_sec == id_sec)
4393     {
4394       stub_entry = h->u.stub_cache;
4395     }
4396   else
4397     {
4398       char *stub_name;
4399
4400       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4401       if (stub_name == NULL)
4402         return NULL;
4403
4404       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4405                                          stub_name, FALSE, FALSE);
4406       if (h != NULL)
4407         h->u.stub_cache = stub_entry;
4408
4409       free (stub_name);
4410     }
4411
4412   return stub_entry;
4413 }
4414
4415 /* Add a new stub entry to the stub hash.  Not all fields of the new
4416    stub entry are initialised.  */
4417
4418 static struct ppc_stub_hash_entry *
4419 ppc_add_stub (const char *stub_name,
4420               asection *section,
4421               struct bfd_link_info *info)
4422 {
4423   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4424   asection *link_sec;
4425   asection *stub_sec;
4426   struct ppc_stub_hash_entry *stub_entry;
4427
4428   link_sec = htab->stub_group[section->id].link_sec;
4429   stub_sec = htab->stub_group[section->id].stub_sec;
4430   if (stub_sec == NULL)
4431     {
4432       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4433       if (stub_sec == NULL)
4434         {
4435           size_t namelen;
4436           bfd_size_type len;
4437           char *s_name;
4438
4439           namelen = strlen (link_sec->name);
4440           len = namelen + sizeof (STUB_SUFFIX);
4441           s_name = bfd_alloc (htab->params->stub_bfd, len);
4442           if (s_name == NULL)
4443             return NULL;
4444
4445           memcpy (s_name, link_sec->name, namelen);
4446           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4447           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4448           if (stub_sec == NULL)
4449             return NULL;
4450           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4451         }
4452       htab->stub_group[section->id].stub_sec = stub_sec;
4453     }
4454
4455   /* Enter this entry into the linker stub hash table.  */
4456   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4457                                      TRUE, FALSE);
4458   if (stub_entry == NULL)
4459     {
4460       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4461                               section->owner, stub_name);
4462       return NULL;
4463     }
4464
4465   stub_entry->stub_sec = stub_sec;
4466   stub_entry->stub_offset = 0;
4467   stub_entry->id_sec = link_sec;
4468   return stub_entry;
4469 }
4470
4471 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4472    not already done.  */
4473
4474 static bfd_boolean
4475 create_got_section (bfd *abfd, struct bfd_link_info *info)
4476 {
4477   asection *got, *relgot;
4478   flagword flags;
4479   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4480
4481   if (!is_ppc64_elf (abfd))
4482     return FALSE;
4483   if (htab == NULL)
4484     return FALSE;
4485
4486   if (!htab->elf.sgot
4487       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4488     return FALSE;
4489
4490   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4491            | SEC_LINKER_CREATED);
4492
4493   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4494   if (!got
4495       || !bfd_set_section_alignment (abfd, got, 3))
4496     return FALSE;
4497
4498   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4499                                                flags | SEC_READONLY);
4500   if (!relgot
4501       || ! bfd_set_section_alignment (abfd, relgot, 3))
4502     return FALSE;
4503
4504   ppc64_elf_tdata (abfd)->got = got;
4505   ppc64_elf_tdata (abfd)->relgot = relgot;
4506   return TRUE;
4507 }
4508
4509 /* Create the dynamic sections, and set up shortcuts.  */
4510
4511 static bfd_boolean
4512 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4513 {
4514   struct ppc_link_hash_table *htab;
4515
4516   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4517     return FALSE;
4518
4519   htab = ppc_hash_table (info);
4520   if (htab == NULL)
4521     return FALSE;
4522
4523   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4524   if (!info->shared)
4525     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4526
4527   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4528       || (!info->shared && !htab->relbss))
4529     abort ();
4530
4531   return TRUE;
4532 }
4533
4534 /* Follow indirect and warning symbol links.  */
4535
4536 static inline struct bfd_link_hash_entry *
4537 follow_link (struct bfd_link_hash_entry *h)
4538 {
4539   while (h->type == bfd_link_hash_indirect
4540          || h->type == bfd_link_hash_warning)
4541     h = h->u.i.link;
4542   return h;
4543 }
4544
4545 static inline struct elf_link_hash_entry *
4546 elf_follow_link (struct elf_link_hash_entry *h)
4547 {
4548   return (struct elf_link_hash_entry *) follow_link (&h->root);
4549 }
4550
4551 static inline struct ppc_link_hash_entry *
4552 ppc_follow_link (struct ppc_link_hash_entry *h)
4553 {
4554   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4555 }
4556
4557 /* Merge PLT info on FROM with that on TO.  */
4558
4559 static void
4560 move_plt_plist (struct ppc_link_hash_entry *from,
4561                 struct ppc_link_hash_entry *to)
4562 {
4563   if (from->elf.plt.plist != NULL)
4564     {
4565       if (to->elf.plt.plist != NULL)
4566         {
4567           struct plt_entry **entp;
4568           struct plt_entry *ent;
4569
4570           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4571             {
4572               struct plt_entry *dent;
4573
4574               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4575                 if (dent->addend == ent->addend)
4576                   {
4577                     dent->plt.refcount += ent->plt.refcount;
4578                     *entp = ent->next;
4579                     break;
4580                   }
4581               if (dent == NULL)
4582                 entp = &ent->next;
4583             }
4584           *entp = to->elf.plt.plist;
4585         }
4586
4587       to->elf.plt.plist = from->elf.plt.plist;
4588       from->elf.plt.plist = NULL;
4589     }
4590 }
4591
4592 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4593
4594 static void
4595 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4596                                 struct elf_link_hash_entry *dir,
4597                                 struct elf_link_hash_entry *ind)
4598 {
4599   struct ppc_link_hash_entry *edir, *eind;
4600
4601   edir = (struct ppc_link_hash_entry *) dir;
4602   eind = (struct ppc_link_hash_entry *) ind;
4603
4604   edir->is_func |= eind->is_func;
4605   edir->is_func_descriptor |= eind->is_func_descriptor;
4606   edir->tls_mask |= eind->tls_mask;
4607   if (eind->oh != NULL)
4608     edir->oh = ppc_follow_link (eind->oh);
4609
4610   /* If called to transfer flags for a weakdef during processing
4611      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4612      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4613   if (!(ELIMINATE_COPY_RELOCS
4614         && eind->elf.root.type != bfd_link_hash_indirect
4615         && edir->elf.dynamic_adjusted))
4616     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4617
4618   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4619   edir->elf.ref_regular |= eind->elf.ref_regular;
4620   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4621   edir->elf.needs_plt |= eind->elf.needs_plt;
4622   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4623
4624   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4625   if (eind->dyn_relocs != NULL)
4626     {
4627       if (edir->dyn_relocs != NULL)
4628         {
4629           struct elf_dyn_relocs **pp;
4630           struct elf_dyn_relocs *p;
4631
4632           /* Add reloc counts against the indirect sym to the direct sym
4633              list.  Merge any entries against the same section.  */
4634           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4635             {
4636               struct elf_dyn_relocs *q;
4637
4638               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4639                 if (q->sec == p->sec)
4640                   {
4641                     q->pc_count += p->pc_count;
4642                     q->count += p->count;
4643                     *pp = p->next;
4644                     break;
4645                   }
4646               if (q == NULL)
4647                 pp = &p->next;
4648             }
4649           *pp = edir->dyn_relocs;
4650         }
4651
4652       edir->dyn_relocs = eind->dyn_relocs;
4653       eind->dyn_relocs = NULL;
4654     }
4655
4656   /* If we were called to copy over info for a weak sym, that's all.
4657      You might think dyn_relocs need not be copied over;  After all,
4658      both syms will be dynamic or both non-dynamic so we're just
4659      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4660      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4661      dyn_relocs in read-only sections, and it does so on what is the
4662      DIR sym here.  */
4663   if (eind->elf.root.type != bfd_link_hash_indirect)
4664     return;
4665
4666   /* Copy over got entries that we may have already seen to the
4667      symbol which just became indirect.  */
4668   if (eind->elf.got.glist != NULL)
4669     {
4670       if (edir->elf.got.glist != NULL)
4671         {
4672           struct got_entry **entp;
4673           struct got_entry *ent;
4674
4675           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4676             {
4677               struct got_entry *dent;
4678
4679               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4680                 if (dent->addend == ent->addend
4681                     && dent->owner == ent->owner
4682                     && dent->tls_type == ent->tls_type)
4683                   {
4684                     dent->got.refcount += ent->got.refcount;
4685                     *entp = ent->next;
4686                     break;
4687                   }
4688               if (dent == NULL)
4689                 entp = &ent->next;
4690             }
4691           *entp = edir->elf.got.glist;
4692         }
4693
4694       edir->elf.got.glist = eind->elf.got.glist;
4695       eind->elf.got.glist = NULL;
4696     }
4697
4698   /* And plt entries.  */
4699   move_plt_plist (eind, edir);
4700
4701   if (eind->elf.dynindx != -1)
4702     {
4703       if (edir->elf.dynindx != -1)
4704         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4705                                 edir->elf.dynstr_index);
4706       edir->elf.dynindx = eind->elf.dynindx;
4707       edir->elf.dynstr_index = eind->elf.dynstr_index;
4708       eind->elf.dynindx = -1;
4709       eind->elf.dynstr_index = 0;
4710     }
4711 }
4712
4713 /* Find the function descriptor hash entry from the given function code
4714    hash entry FH.  Link the entries via their OH fields.  */
4715
4716 static struct ppc_link_hash_entry *
4717 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4718 {
4719   struct ppc_link_hash_entry *fdh = fh->oh;
4720
4721   if (fdh == NULL)
4722     {
4723       const char *fd_name = fh->elf.root.root.string + 1;
4724
4725       fdh = (struct ppc_link_hash_entry *)
4726         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4727       if (fdh == NULL)
4728         return fdh;
4729
4730       fdh->is_func_descriptor = 1;
4731       fdh->oh = fh;
4732       fh->is_func = 1;
4733       fh->oh = fdh;
4734     }
4735
4736   return ppc_follow_link (fdh);
4737 }
4738
4739 /* Make a fake function descriptor sym for the code sym FH.  */
4740
4741 static struct ppc_link_hash_entry *
4742 make_fdh (struct bfd_link_info *info,
4743           struct ppc_link_hash_entry *fh)
4744 {
4745   bfd *abfd;
4746   asymbol *newsym;
4747   struct bfd_link_hash_entry *bh;
4748   struct ppc_link_hash_entry *fdh;
4749
4750   abfd = fh->elf.root.u.undef.abfd;
4751   newsym = bfd_make_empty_symbol (abfd);
4752   newsym->name = fh->elf.root.root.string + 1;
4753   newsym->section = bfd_und_section_ptr;
4754   newsym->value = 0;
4755   newsym->flags = BSF_WEAK;
4756
4757   bh = NULL;
4758   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4759                                          newsym->flags, newsym->section,
4760                                          newsym->value, NULL, FALSE, FALSE,
4761                                          &bh))
4762     return NULL;
4763
4764   fdh = (struct ppc_link_hash_entry *) bh;
4765   fdh->elf.non_elf = 0;
4766   fdh->fake = 1;
4767   fdh->is_func_descriptor = 1;
4768   fdh->oh = fh;
4769   fh->is_func = 1;
4770   fh->oh = fdh;
4771   return fdh;
4772 }
4773
4774 /* Fix function descriptor symbols defined in .opd sections to be
4775    function type.  */
4776
4777 static bfd_boolean
4778 ppc64_elf_add_symbol_hook (bfd *ibfd,
4779                            struct bfd_link_info *info,
4780                            Elf_Internal_Sym *isym,
4781                            const char **name,
4782                            flagword *flags ATTRIBUTE_UNUSED,
4783                            asection **sec,
4784                            bfd_vma *value ATTRIBUTE_UNUSED)
4785 {
4786   if ((ibfd->flags & DYNAMIC) == 0
4787       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4788     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4789
4790   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4791     {
4792       if ((ibfd->flags & DYNAMIC) == 0)
4793         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4794     }
4795   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4796     ;
4797   else if (*sec != NULL
4798            && strcmp ((*sec)->name, ".opd") == 0)
4799     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4800
4801   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4802     {
4803       if (abiversion (ibfd) == 0)
4804         set_abiversion (ibfd, 2);
4805       else if (abiversion (ibfd) == 1)
4806         {
4807           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4808                                     " for ABI version 1\n"), name);
4809           bfd_set_error (bfd_error_bad_value);
4810           return FALSE;
4811         }
4812     }
4813
4814   return TRUE;
4815 }
4816
4817 /* Merge non-visibility st_other attributes: local entry point.  */
4818
4819 static void
4820 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4821                                   const Elf_Internal_Sym *isym,
4822                                   bfd_boolean definition,
4823                                   bfd_boolean dynamic)
4824 {
4825   if (definition && !dynamic)
4826     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4827                 | ELF_ST_VISIBILITY (h->other));
4828 }
4829
4830 /* This function makes an old ABI object reference to ".bar" cause the
4831    inclusion of a new ABI object archive that defines "bar".
4832    NAME is a symbol defined in an archive.  Return a symbol in the hash
4833    table that might be satisfied by the archive symbols.  */
4834
4835 static struct elf_link_hash_entry *
4836 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4837                                  struct bfd_link_info *info,
4838                                  const char *name)
4839 {
4840   struct elf_link_hash_entry *h;
4841   char *dot_name;
4842   size_t len;
4843
4844   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4845   if (h != NULL
4846       /* Don't return this sym if it is a fake function descriptor
4847          created by add_symbol_adjust.  */
4848       && !(h->root.type == bfd_link_hash_undefweak
4849            && ((struct ppc_link_hash_entry *) h)->fake))
4850     return h;
4851
4852   if (name[0] == '.')
4853     return h;
4854
4855   len = strlen (name);
4856   dot_name = bfd_alloc (abfd, len + 2);
4857   if (dot_name == NULL)
4858     return (struct elf_link_hash_entry *) 0 - 1;
4859   dot_name[0] = '.';
4860   memcpy (dot_name + 1, name, len + 1);
4861   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4862   bfd_release (abfd, dot_name);
4863   return h;
4864 }
4865
4866 /* This function satisfies all old ABI object references to ".bar" if a
4867    new ABI object defines "bar".  Well, at least, undefined dot symbols
4868    are made weak.  This stops later archive searches from including an
4869    object if we already have a function descriptor definition.  It also
4870    prevents the linker complaining about undefined symbols.
4871    We also check and correct mismatched symbol visibility here.  The
4872    most restrictive visibility of the function descriptor and the
4873    function entry symbol is used.  */
4874
4875 static bfd_boolean
4876 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4877 {
4878   struct ppc_link_hash_table *htab;
4879   struct ppc_link_hash_entry *fdh;
4880
4881   if (eh->elf.root.type == bfd_link_hash_indirect)
4882     return TRUE;
4883
4884   if (eh->elf.root.type == bfd_link_hash_warning)
4885     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4886
4887   if (eh->elf.root.root.string[0] != '.')
4888     abort ();
4889
4890   htab = ppc_hash_table (info);
4891   if (htab == NULL)
4892     return FALSE;
4893
4894   fdh = lookup_fdh (eh, htab);
4895   if (fdh == NULL)
4896     {
4897       if (!info->relocatable
4898           && (eh->elf.root.type == bfd_link_hash_undefined
4899               || eh->elf.root.type == bfd_link_hash_undefweak)
4900           && eh->elf.ref_regular)
4901         {
4902           /* Make an undefweak function descriptor sym, which is enough to
4903              pull in an --as-needed shared lib, but won't cause link
4904              errors.  Archives are handled elsewhere.  */
4905           fdh = make_fdh (info, eh);
4906           if (fdh == NULL)
4907             return FALSE;
4908           fdh->elf.ref_regular = 1;
4909         }
4910     }
4911   else
4912     {
4913       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4914       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4915       if (entry_vis < descr_vis)
4916         fdh->elf.other += entry_vis - descr_vis;
4917       else if (entry_vis > descr_vis)
4918         eh->elf.other += descr_vis - entry_vis;
4919
4920       if ((fdh->elf.root.type == bfd_link_hash_defined
4921            || fdh->elf.root.type == bfd_link_hash_defweak)
4922           && eh->elf.root.type == bfd_link_hash_undefined)
4923         {
4924           eh->elf.root.type = bfd_link_hash_undefweak;
4925           eh->was_undefined = 1;
4926           htab->twiddled_syms = 1;
4927         }
4928     }
4929
4930   return TRUE;
4931 }
4932
4933 /* Set up opd section info and abiversion for IBFD, and process list
4934    of dot-symbols we made in link_hash_newfunc.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4938 {
4939   struct ppc_link_hash_table *htab;
4940   struct ppc_link_hash_entry **p, *eh;
4941
4942   if (!is_ppc64_elf (info->output_bfd))
4943     return TRUE;
4944   htab = ppc_hash_table (info);
4945   if (htab == NULL)
4946     return FALSE;
4947
4948   if (is_ppc64_elf (ibfd))
4949     {
4950       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4951
4952       if (opd != NULL && opd->size != 0)
4953         {
4954           if (abiversion (ibfd) == 0)
4955             set_abiversion (ibfd, 1);
4956           else if (abiversion (ibfd) == 2)
4957             {
4958               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4959                                         " version %d\n"),
4960                                       ibfd, abiversion (ibfd));
4961               bfd_set_error (bfd_error_bad_value);
4962               return FALSE;
4963             }
4964
4965           if ((ibfd->flags & DYNAMIC) == 0
4966               && (opd->flags & SEC_RELOC) != 0
4967               && opd->reloc_count != 0
4968               && !bfd_is_abs_section (opd->output_section))
4969             {
4970               /* Garbage collection needs some extra help with .opd sections.
4971                  We don't want to necessarily keep everything referenced by
4972                  relocs in .opd, as that would keep all functions.  Instead,
4973                  if we reference an .opd symbol (a function descriptor), we
4974                  want to keep the function code symbol's section.  This is
4975                  easy for global symbols, but for local syms we need to keep
4976                  information about the associated function section.  */
4977               bfd_size_type amt;
4978               asection **opd_sym_map;
4979
4980               amt = opd->size * sizeof (*opd_sym_map) / 8;
4981               opd_sym_map = bfd_zalloc (ibfd, amt);
4982               if (opd_sym_map == NULL)
4983                 return FALSE;
4984               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4985               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4986               ppc64_elf_section_data (opd)->sec_type = sec_opd;
4987             }
4988         }
4989
4990       /* For input files without an explicit abiversion in e_flags
4991          we should have flagged any with symbol st_other bits set
4992          as ELFv1 and above flagged those with .opd as ELFv2.
4993          Set the output abiversion if not yet set, and for any input
4994          still ambiguous, take its abiversion from the output.
4995          Differences in ABI are reported later.  */
4996       if (abiversion (info->output_bfd) == 0)
4997         set_abiversion (info->output_bfd, abiversion (ibfd));
4998       else if (abiversion (ibfd) == 0)
4999         set_abiversion (ibfd, abiversion (info->output_bfd));
5000
5001       p = &htab->dot_syms;
5002       while ((eh = *p) != NULL)
5003         {
5004           *p = NULL;
5005           if (&eh->elf == htab->elf.hgot)
5006             ;
5007           else if (htab->elf.hgot == NULL
5008                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5009             htab->elf.hgot = &eh->elf;
5010           else if (!add_symbol_adjust (eh, info))
5011             return FALSE;
5012           p = &eh->u.next_dot_sym;
5013         }
5014     }
5015
5016   /* Clear the list for non-ppc64 input files.  */
5017   p = &htab->dot_syms;
5018   while ((eh = *p) != NULL)
5019     {
5020       *p = NULL;
5021       p = &eh->u.next_dot_sym;
5022     }
5023
5024   /* We need to fix the undefs list for any syms we have twiddled to
5025      undef_weak.  */
5026   if (htab->twiddled_syms)
5027     {
5028       bfd_link_repair_undef_list (&htab->elf.root);
5029       htab->twiddled_syms = 0;
5030     }
5031   return TRUE;
5032 }
5033
5034 /* Undo hash table changes when an --as-needed input file is determined
5035    not to be needed.  */
5036
5037 static bfd_boolean
5038 ppc64_elf_notice_as_needed (bfd *ibfd,
5039                             struct bfd_link_info *info,
5040                             enum notice_asneeded_action act)
5041 {
5042   if (act == notice_not_needed)
5043     {
5044       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5045
5046       if (htab == NULL)
5047         return FALSE;
5048
5049       htab->dot_syms = NULL;
5050     }
5051   return _bfd_elf_notice_as_needed (ibfd, info, act);
5052 }
5053
5054 /* If --just-symbols against a final linked binary, then assume we need
5055    toc adjusting stubs when calling functions defined there.  */
5056
5057 static void
5058 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5059 {
5060   if ((sec->flags & SEC_CODE) != 0
5061       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5062       && is_ppc64_elf (sec->owner))
5063     {
5064       if (abiversion (sec->owner) >= 2
5065           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5066         sec->has_toc_reloc = 1;
5067     }
5068   _bfd_elf_link_just_syms (sec, info);
5069 }
5070
5071 static struct plt_entry **
5072 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5073                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5074 {
5075   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5076   struct plt_entry **local_plt;
5077   unsigned char *local_got_tls_masks;
5078
5079   if (local_got_ents == NULL)
5080     {
5081       bfd_size_type size = symtab_hdr->sh_info;
5082
5083       size *= (sizeof (*local_got_ents)
5084                + sizeof (*local_plt)
5085                + sizeof (*local_got_tls_masks));
5086       local_got_ents = bfd_zalloc (abfd, size);
5087       if (local_got_ents == NULL)
5088         return NULL;
5089       elf_local_got_ents (abfd) = local_got_ents;
5090     }
5091
5092   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5093     {
5094       struct got_entry *ent;
5095
5096       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5097         if (ent->addend == r_addend
5098             && ent->owner == abfd
5099             && ent->tls_type == tls_type)
5100           break;
5101       if (ent == NULL)
5102         {
5103           bfd_size_type amt = sizeof (*ent);
5104           ent = bfd_alloc (abfd, amt);
5105           if (ent == NULL)
5106             return FALSE;
5107           ent->next = local_got_ents[r_symndx];
5108           ent->addend = r_addend;
5109           ent->owner = abfd;
5110           ent->tls_type = tls_type;
5111           ent->is_indirect = FALSE;
5112           ent->got.refcount = 0;
5113           local_got_ents[r_symndx] = ent;
5114         }
5115       ent->got.refcount += 1;
5116     }
5117
5118   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5119   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5120   local_got_tls_masks[r_symndx] |= tls_type;
5121
5122   return local_plt + r_symndx;
5123 }
5124
5125 static bfd_boolean
5126 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5127 {
5128   struct plt_entry *ent;
5129
5130   for (ent = *plist; ent != NULL; ent = ent->next)
5131     if (ent->addend == addend)
5132       break;
5133   if (ent == NULL)
5134     {
5135       bfd_size_type amt = sizeof (*ent);
5136       ent = bfd_alloc (abfd, amt);
5137       if (ent == NULL)
5138         return FALSE;
5139       ent->next = *plist;
5140       ent->addend = addend;
5141       ent->plt.refcount = 0;
5142       *plist = ent;
5143     }
5144   ent->plt.refcount += 1;
5145   return TRUE;
5146 }
5147
5148 static bfd_boolean
5149 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5150 {
5151   return (r_type == R_PPC64_REL24
5152           || r_type == R_PPC64_REL14
5153           || r_type == R_PPC64_REL14_BRTAKEN
5154           || r_type == R_PPC64_REL14_BRNTAKEN
5155           || r_type == R_PPC64_ADDR24
5156           || r_type == R_PPC64_ADDR14
5157           || r_type == R_PPC64_ADDR14_BRTAKEN
5158           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5159 }
5160
5161 /* Look through the relocs for a section during the first phase, and
5162    calculate needed space in the global offset table, procedure
5163    linkage table, and dynamic reloc sections.  */
5164
5165 static bfd_boolean
5166 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5167                         asection *sec, const Elf_Internal_Rela *relocs)
5168 {
5169   struct ppc_link_hash_table *htab;
5170   Elf_Internal_Shdr *symtab_hdr;
5171   struct elf_link_hash_entry **sym_hashes;
5172   const Elf_Internal_Rela *rel;
5173   const Elf_Internal_Rela *rel_end;
5174   asection *sreloc;
5175   asection **opd_sym_map;
5176   struct elf_link_hash_entry *tga, *dottga;
5177
5178   if (info->relocatable)
5179     return TRUE;
5180
5181   /* Don't do anything special with non-loaded, non-alloced sections.
5182      In particular, any relocs in such sections should not affect GOT
5183      and PLT reference counting (ie. we don't allow them to create GOT
5184      or PLT entries), there's no possibility or desire to optimize TLS
5185      relocs, and there's not much point in propagating relocs to shared
5186      libs that the dynamic linker won't relocate.  */
5187   if ((sec->flags & SEC_ALLOC) == 0)
5188     return TRUE;
5189
5190   BFD_ASSERT (is_ppc64_elf (abfd));
5191
5192   htab = ppc_hash_table (info);
5193   if (htab == NULL)
5194     return FALSE;
5195
5196   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5197                               FALSE, FALSE, TRUE);
5198   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5199                                  FALSE, FALSE, TRUE);
5200   symtab_hdr = &elf_symtab_hdr (abfd);
5201   sym_hashes = elf_sym_hashes (abfd);
5202   sreloc = NULL;
5203   opd_sym_map = NULL;
5204   if (ppc64_elf_section_data (sec) != NULL
5205       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5206     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5207
5208   rel_end = relocs + sec->reloc_count;
5209   for (rel = relocs; rel < rel_end; rel++)
5210     {
5211       unsigned long r_symndx;
5212       struct elf_link_hash_entry *h;
5213       enum elf_ppc64_reloc_type r_type;
5214       int tls_type;
5215       struct _ppc64_elf_section_data *ppc64_sec;
5216       struct plt_entry **ifunc;
5217
5218       r_symndx = ELF64_R_SYM (rel->r_info);
5219       if (r_symndx < symtab_hdr->sh_info)
5220         h = NULL;
5221       else
5222         {
5223           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5224           h = elf_follow_link (h);
5225
5226           /* PR15323, ref flags aren't set for references in the same
5227              object.  */
5228           h->root.non_ir_ref = 1;
5229
5230           if (h == htab->elf.hgot)
5231             sec->has_toc_reloc = 1;
5232         }
5233
5234       tls_type = 0;
5235       ifunc = NULL;
5236       if (h != NULL)
5237         {
5238           if (h->type == STT_GNU_IFUNC)
5239             {
5240               h->needs_plt = 1;
5241               ifunc = &h->plt.plist;
5242             }
5243         }
5244       else
5245         {
5246           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5247                                                           abfd, r_symndx);
5248           if (isym == NULL)
5249             return FALSE;
5250
5251           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5252             {
5253               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5254                                              rel->r_addend, PLT_IFUNC);
5255               if (ifunc == NULL)
5256                 return FALSE;
5257             }
5258         }
5259       r_type = ELF64_R_TYPE (rel->r_info);
5260       if (is_branch_reloc (r_type))
5261         {
5262           if (h != NULL && (h == tga || h == dottga))
5263             {
5264               if (rel != relocs
5265                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5266                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5267                 /* We have a new-style __tls_get_addr call with a marker
5268                    reloc.  */
5269                 ;
5270               else
5271                 /* Mark this section as having an old-style call.  */
5272                 sec->has_tls_get_addr_call = 1;
5273             }
5274
5275           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5276           if (ifunc != NULL
5277               && !update_plt_info (abfd, ifunc, rel->r_addend))
5278             return FALSE;
5279         }
5280
5281       switch (r_type)
5282         {
5283         case R_PPC64_TLSGD:
5284         case R_PPC64_TLSLD:
5285           /* These special tls relocs tie a call to __tls_get_addr with
5286              its parameter symbol.  */
5287           break;
5288
5289         case R_PPC64_GOT_TLSLD16:
5290         case R_PPC64_GOT_TLSLD16_LO:
5291         case R_PPC64_GOT_TLSLD16_HI:
5292         case R_PPC64_GOT_TLSLD16_HA:
5293           tls_type = TLS_TLS | TLS_LD;
5294           goto dogottls;
5295
5296         case R_PPC64_GOT_TLSGD16:
5297         case R_PPC64_GOT_TLSGD16_LO:
5298         case R_PPC64_GOT_TLSGD16_HI:
5299         case R_PPC64_GOT_TLSGD16_HA:
5300           tls_type = TLS_TLS | TLS_GD;
5301           goto dogottls;
5302
5303         case R_PPC64_GOT_TPREL16_DS:
5304         case R_PPC64_GOT_TPREL16_LO_DS:
5305         case R_PPC64_GOT_TPREL16_HI:
5306         case R_PPC64_GOT_TPREL16_HA:
5307           if (!info->executable)
5308             info->flags |= DF_STATIC_TLS;
5309           tls_type = TLS_TLS | TLS_TPREL;
5310           goto dogottls;
5311
5312         case R_PPC64_GOT_DTPREL16_DS:
5313         case R_PPC64_GOT_DTPREL16_LO_DS:
5314         case R_PPC64_GOT_DTPREL16_HI:
5315         case R_PPC64_GOT_DTPREL16_HA:
5316           tls_type = TLS_TLS | TLS_DTPREL;
5317         dogottls:
5318           sec->has_tls_reloc = 1;
5319           /* Fall thru */
5320
5321         case R_PPC64_GOT16:
5322         case R_PPC64_GOT16_DS:
5323         case R_PPC64_GOT16_HA:
5324         case R_PPC64_GOT16_HI:
5325         case R_PPC64_GOT16_LO:
5326         case R_PPC64_GOT16_LO_DS:
5327           /* This symbol requires a global offset table entry.  */
5328           sec->has_toc_reloc = 1;
5329           if (r_type == R_PPC64_GOT_TLSLD16
5330               || r_type == R_PPC64_GOT_TLSGD16
5331               || r_type == R_PPC64_GOT_TPREL16_DS
5332               || r_type == R_PPC64_GOT_DTPREL16_DS
5333               || r_type == R_PPC64_GOT16
5334               || r_type == R_PPC64_GOT16_DS)
5335             {
5336               htab->do_multi_toc = 1;
5337               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5338             }
5339
5340           if (ppc64_elf_tdata (abfd)->got == NULL
5341               && !create_got_section (abfd, info))
5342             return FALSE;
5343
5344           if (h != NULL)
5345             {
5346               struct ppc_link_hash_entry *eh;
5347               struct got_entry *ent;
5348
5349               eh = (struct ppc_link_hash_entry *) h;
5350               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5351                 if (ent->addend == rel->r_addend
5352                     && ent->owner == abfd
5353                     && ent->tls_type == tls_type)
5354                   break;
5355               if (ent == NULL)
5356                 {
5357                   bfd_size_type amt = sizeof (*ent);
5358                   ent = bfd_alloc (abfd, amt);
5359                   if (ent == NULL)
5360                     return FALSE;
5361                   ent->next = eh->elf.got.glist;
5362                   ent->addend = rel->r_addend;
5363                   ent->owner = abfd;
5364                   ent->tls_type = tls_type;
5365                   ent->is_indirect = FALSE;
5366                   ent->got.refcount = 0;
5367                   eh->elf.got.glist = ent;
5368                 }
5369               ent->got.refcount += 1;
5370               eh->tls_mask |= tls_type;
5371             }
5372           else
5373             /* This is a global offset table entry for a local symbol.  */
5374             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5375                                         rel->r_addend, tls_type))
5376               return FALSE;
5377
5378           /* We may also need a plt entry if the symbol turns out to be
5379              an ifunc.  */
5380           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5381             {
5382               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5383                 return FALSE;
5384             }
5385           break;
5386
5387         case R_PPC64_PLT16_HA:
5388         case R_PPC64_PLT16_HI:
5389         case R_PPC64_PLT16_LO:
5390         case R_PPC64_PLT32:
5391         case R_PPC64_PLT64:
5392           /* This symbol requires a procedure linkage table entry.  We
5393              actually build the entry in adjust_dynamic_symbol,
5394              because this might be a case of linking PIC code without
5395              linking in any dynamic objects, in which case we don't
5396              need to generate a procedure linkage table after all.  */
5397           if (h == NULL)
5398             {
5399               /* It does not make sense to have a procedure linkage
5400                  table entry for a local symbol.  */
5401               bfd_set_error (bfd_error_bad_value);
5402               return FALSE;
5403             }
5404           else
5405             {
5406               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5407                 return FALSE;
5408               h->needs_plt = 1;
5409               if (h->root.root.string[0] == '.'
5410                   && h->root.root.string[1] != '\0')
5411                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5412             }
5413           break;
5414
5415           /* The following relocations don't need to propagate the
5416              relocation if linking a shared object since they are
5417              section relative.  */
5418         case R_PPC64_SECTOFF:
5419         case R_PPC64_SECTOFF_LO:
5420         case R_PPC64_SECTOFF_HI:
5421         case R_PPC64_SECTOFF_HA:
5422         case R_PPC64_SECTOFF_DS:
5423         case R_PPC64_SECTOFF_LO_DS:
5424         case R_PPC64_DTPREL16:
5425         case R_PPC64_DTPREL16_LO:
5426         case R_PPC64_DTPREL16_HI:
5427         case R_PPC64_DTPREL16_HA:
5428         case R_PPC64_DTPREL16_DS:
5429         case R_PPC64_DTPREL16_LO_DS:
5430         case R_PPC64_DTPREL16_HIGH:
5431         case R_PPC64_DTPREL16_HIGHA:
5432         case R_PPC64_DTPREL16_HIGHER:
5433         case R_PPC64_DTPREL16_HIGHERA:
5434         case R_PPC64_DTPREL16_HIGHEST:
5435         case R_PPC64_DTPREL16_HIGHESTA:
5436           break;
5437
5438           /* Nor do these.  */
5439         case R_PPC64_REL16:
5440         case R_PPC64_REL16_LO:
5441         case R_PPC64_REL16_HI:
5442         case R_PPC64_REL16_HA:
5443           break;
5444
5445           /* Not supported as a dynamic relocation.  */
5446         case R_PPC64_ADDR64_LOCAL:
5447           if (info->shared)
5448             {
5449               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5450                 ppc_howto_init ();
5451               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5452                                         "in shared libraries and PIEs.\n"),
5453                                       abfd, sec, rel->r_offset,
5454                                       ppc64_elf_howto_table[r_type]->name);
5455               bfd_set_error (bfd_error_bad_value);
5456               return FALSE;
5457             }
5458           break;
5459
5460         case R_PPC64_TOC16:
5461         case R_PPC64_TOC16_DS:
5462           htab->do_multi_toc = 1;
5463           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5464         case R_PPC64_TOC16_LO:
5465         case R_PPC64_TOC16_HI:
5466         case R_PPC64_TOC16_HA:
5467         case R_PPC64_TOC16_LO_DS:
5468           sec->has_toc_reloc = 1;
5469           break;
5470
5471           /* This relocation describes the C++ object vtable hierarchy.
5472              Reconstruct it for later use during GC.  */
5473         case R_PPC64_GNU_VTINHERIT:
5474           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5475             return FALSE;
5476           break;
5477
5478           /* This relocation describes which C++ vtable entries are actually
5479              used.  Record for later use during GC.  */
5480         case R_PPC64_GNU_VTENTRY:
5481           BFD_ASSERT (h != NULL);
5482           if (h != NULL
5483               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5484             return FALSE;
5485           break;
5486
5487         case R_PPC64_REL14:
5488         case R_PPC64_REL14_BRTAKEN:
5489         case R_PPC64_REL14_BRNTAKEN:
5490           {
5491             asection *dest = NULL;
5492
5493             /* Heuristic: If jumping outside our section, chances are
5494                we are going to need a stub.  */
5495             if (h != NULL)
5496               {
5497                 /* If the sym is weak it may be overridden later, so
5498                    don't assume we know where a weak sym lives.  */
5499                 if (h->root.type == bfd_link_hash_defined)
5500                   dest = h->root.u.def.section;
5501               }
5502             else
5503               {
5504                 Elf_Internal_Sym *isym;
5505
5506                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5507                                               abfd, r_symndx);
5508                 if (isym == NULL)
5509                   return FALSE;
5510
5511                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5512               }
5513
5514             if (dest != sec)
5515               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5516           }
5517           /* Fall through.  */
5518
5519         case R_PPC64_REL24:
5520           if (h != NULL && ifunc == NULL)
5521             {
5522               /* We may need a .plt entry if the function this reloc
5523                  refers to is in a shared lib.  */
5524               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5525                 return FALSE;
5526               h->needs_plt = 1;
5527               if (h->root.root.string[0] == '.'
5528                   && h->root.root.string[1] != '\0')
5529                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5530               if (h == tga || h == dottga)
5531                 sec->has_tls_reloc = 1;
5532             }
5533           break;
5534
5535         case R_PPC64_TPREL64:
5536           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5537           if (!info->executable)
5538             info->flags |= DF_STATIC_TLS;
5539           goto dotlstoc;
5540
5541         case R_PPC64_DTPMOD64:
5542           if (rel + 1 < rel_end
5543               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5544               && rel[1].r_offset == rel->r_offset + 8)
5545             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5546           else
5547             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5548           goto dotlstoc;
5549
5550         case R_PPC64_DTPREL64:
5551           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5552           if (rel != relocs
5553               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5554               && rel[-1].r_offset == rel->r_offset - 8)
5555             /* This is the second reloc of a dtpmod, dtprel pair.
5556                Don't mark with TLS_DTPREL.  */
5557             goto dodyn;
5558
5559         dotlstoc:
5560           sec->has_tls_reloc = 1;
5561           if (h != NULL)
5562             {
5563               struct ppc_link_hash_entry *eh;
5564               eh = (struct ppc_link_hash_entry *) h;
5565               eh->tls_mask |= tls_type;
5566             }
5567           else
5568             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5569                                         rel->r_addend, tls_type))
5570               return FALSE;
5571
5572           ppc64_sec = ppc64_elf_section_data (sec);
5573           if (ppc64_sec->sec_type != sec_toc)
5574             {
5575               bfd_size_type amt;
5576
5577               /* One extra to simplify get_tls_mask.  */
5578               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5579               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5580               if (ppc64_sec->u.toc.symndx == NULL)
5581                 return FALSE;
5582               amt = sec->size * sizeof (bfd_vma) / 8;
5583               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5584               if (ppc64_sec->u.toc.add == NULL)
5585                 return FALSE;
5586               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5587               ppc64_sec->sec_type = sec_toc;
5588             }
5589           BFD_ASSERT (rel->r_offset % 8 == 0);
5590           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5591           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5592
5593           /* Mark the second slot of a GD or LD entry.
5594              -1 to indicate GD and -2 to indicate LD.  */
5595           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5596             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5597           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5598             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5599           goto dodyn;
5600
5601         case R_PPC64_TPREL16:
5602         case R_PPC64_TPREL16_LO:
5603         case R_PPC64_TPREL16_HI:
5604         case R_PPC64_TPREL16_HA:
5605         case R_PPC64_TPREL16_DS:
5606         case R_PPC64_TPREL16_LO_DS:
5607         case R_PPC64_TPREL16_HIGH:
5608         case R_PPC64_TPREL16_HIGHA:
5609         case R_PPC64_TPREL16_HIGHER:
5610         case R_PPC64_TPREL16_HIGHERA:
5611         case R_PPC64_TPREL16_HIGHEST:
5612         case R_PPC64_TPREL16_HIGHESTA:
5613           if (info->shared)
5614             {
5615               if (!info->executable)
5616                 info->flags |= DF_STATIC_TLS;
5617               goto dodyn;
5618             }
5619           break;
5620
5621         case R_PPC64_ADDR64:
5622           if (opd_sym_map != NULL
5623               && rel + 1 < rel_end
5624               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5625             {
5626               if (h != NULL)
5627                 {
5628                   if (h->root.root.string[0] == '.'
5629                       && h->root.root.string[1] != 0
5630                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5631                     ;
5632                   else
5633                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5634                 }
5635               else
5636                 {
5637                   asection *s;
5638                   Elf_Internal_Sym *isym;
5639
5640                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5641                                                 abfd, r_symndx);
5642                   if (isym == NULL)
5643                     return FALSE;
5644
5645                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5646                   if (s != NULL && s != sec)
5647                     opd_sym_map[rel->r_offset / 8] = s;
5648                 }
5649             }
5650           /* Fall through.  */
5651
5652         case R_PPC64_ADDR16:
5653         case R_PPC64_ADDR16_DS:
5654         case R_PPC64_ADDR16_HA:
5655         case R_PPC64_ADDR16_HI:
5656         case R_PPC64_ADDR16_HIGH:
5657         case R_PPC64_ADDR16_HIGHA:
5658         case R_PPC64_ADDR16_HIGHER:
5659         case R_PPC64_ADDR16_HIGHERA:
5660         case R_PPC64_ADDR16_HIGHEST:
5661         case R_PPC64_ADDR16_HIGHESTA:
5662         case R_PPC64_ADDR16_LO:
5663         case R_PPC64_ADDR16_LO_DS:
5664           if (h != NULL && !info->shared && abiversion (abfd) != 1
5665               && rel->r_addend == 0)
5666             {
5667               /* We may need a .plt entry if this reloc refers to a
5668                  function in a shared lib.  */
5669               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5670                 return FALSE;
5671               h->pointer_equality_needed = 1;
5672             }
5673           /* Fall through.  */
5674
5675         case R_PPC64_REL30:
5676         case R_PPC64_REL32:
5677         case R_PPC64_REL64:
5678         case R_PPC64_ADDR14:
5679         case R_PPC64_ADDR14_BRNTAKEN:
5680         case R_PPC64_ADDR14_BRTAKEN:
5681         case R_PPC64_ADDR24:
5682         case R_PPC64_ADDR32:
5683         case R_PPC64_UADDR16:
5684         case R_PPC64_UADDR32:
5685         case R_PPC64_UADDR64:
5686         case R_PPC64_TOC:
5687           if (h != NULL && !info->shared)
5688             /* We may need a copy reloc.  */
5689             h->non_got_ref = 1;
5690
5691           /* Don't propagate .opd relocs.  */
5692           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5693             break;
5694
5695           /* If we are creating a shared library, and this is a reloc
5696              against a global symbol, or a non PC relative reloc
5697              against a local symbol, then we need to copy the reloc
5698              into the shared library.  However, if we are linking with
5699              -Bsymbolic, we do not need to copy a reloc against a
5700              global symbol which is defined in an object we are
5701              including in the link (i.e., DEF_REGULAR is set).  At
5702              this point we have not seen all the input files, so it is
5703              possible that DEF_REGULAR is not set now but will be set
5704              later (it is never cleared).  In case of a weak definition,
5705              DEF_REGULAR may be cleared later by a strong definition in
5706              a shared library.  We account for that possibility below by
5707              storing information in the dyn_relocs field of the hash
5708              table entry.  A similar situation occurs when creating
5709              shared libraries and symbol visibility changes render the
5710              symbol local.
5711
5712              If on the other hand, we are creating an executable, we
5713              may need to keep relocations for symbols satisfied by a
5714              dynamic library if we manage to avoid copy relocs for the
5715              symbol.  */
5716         dodyn:
5717           if ((info->shared
5718                && (must_be_dyn_reloc (info, r_type)
5719                    || (h != NULL
5720                        && (!SYMBOLIC_BIND (info, h)
5721                            || h->root.type == bfd_link_hash_defweak
5722                            || !h->def_regular))))
5723               || (ELIMINATE_COPY_RELOCS
5724                   && !info->shared
5725                   && h != NULL
5726                   && (h->root.type == bfd_link_hash_defweak
5727                       || !h->def_regular))
5728               || (!info->shared
5729                   && ifunc != NULL))
5730             {
5731               /* We must copy these reloc types into the output file.
5732                  Create a reloc section in dynobj and make room for
5733                  this reloc.  */
5734               if (sreloc == NULL)
5735                 {
5736                   sreloc = _bfd_elf_make_dynamic_reloc_section
5737                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5738
5739                   if (sreloc == NULL)
5740                     return FALSE;
5741                 }
5742
5743               /* If this is a global symbol, we count the number of
5744                  relocations we need for this symbol.  */
5745               if (h != NULL)
5746                 {
5747                   struct elf_dyn_relocs *p;
5748                   struct elf_dyn_relocs **head;
5749
5750                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5751                   p = *head;
5752                   if (p == NULL || p->sec != sec)
5753                     {
5754                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5755                       if (p == NULL)
5756                         return FALSE;
5757                       p->next = *head;
5758                       *head = p;
5759                       p->sec = sec;
5760                       p->count = 0;
5761                       p->pc_count = 0;
5762                     }
5763                   p->count += 1;
5764                   if (!must_be_dyn_reloc (info, r_type))
5765                     p->pc_count += 1;
5766                 }
5767               else
5768                 {
5769                   /* Track dynamic relocs needed for local syms too.
5770                      We really need local syms available to do this
5771                      easily.  Oh well.  */
5772                   struct ppc_dyn_relocs *p;
5773                   struct ppc_dyn_relocs **head;
5774                   bfd_boolean is_ifunc;
5775                   asection *s;
5776                   void *vpp;
5777                   Elf_Internal_Sym *isym;
5778
5779                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5780                                                 abfd, r_symndx);
5781                   if (isym == NULL)
5782                     return FALSE;
5783
5784                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5785                   if (s == NULL)
5786                     s = sec;
5787
5788                   vpp = &elf_section_data (s)->local_dynrel;
5789                   head = (struct ppc_dyn_relocs **) vpp;
5790                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5791                   p = *head;
5792                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5793                     p = p->next;
5794                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5795                     {
5796                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5797                       if (p == NULL)
5798                         return FALSE;
5799                       p->next = *head;
5800                       *head = p;
5801                       p->sec = sec;
5802                       p->ifunc = is_ifunc;
5803                       p->count = 0;
5804                     }
5805                   p->count += 1;
5806                 }
5807             }
5808           break;
5809
5810         default:
5811           break;
5812         }
5813     }
5814
5815   return TRUE;
5816 }
5817
5818 /* Merge backend specific data from an object file to the output
5819    object file when linking.  */
5820
5821 static bfd_boolean
5822 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5823 {
5824   unsigned long iflags, oflags;
5825
5826   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5827     return TRUE;
5828
5829   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5830     return TRUE;
5831
5832   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5833     return FALSE;
5834
5835   iflags = elf_elfheader (ibfd)->e_flags;
5836   oflags = elf_elfheader (obfd)->e_flags;
5837
5838   if (iflags & ~EF_PPC64_ABI)
5839     {
5840       (*_bfd_error_handler)
5841         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5842       bfd_set_error (bfd_error_bad_value);
5843       return FALSE;
5844     }
5845   else if (iflags != oflags && iflags != 0)
5846     {
5847       (*_bfd_error_handler)
5848         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5849          ibfd, iflags, oflags);
5850       bfd_set_error (bfd_error_bad_value);
5851       return FALSE;
5852     }
5853
5854   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5855   _bfd_elf_merge_object_attributes (ibfd, obfd);
5856
5857   return TRUE;
5858 }
5859
5860 static bfd_boolean
5861 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5862 {
5863   /* Print normal ELF private data.  */
5864   _bfd_elf_print_private_bfd_data (abfd, ptr);
5865
5866   if (elf_elfheader (abfd)->e_flags != 0)
5867     {
5868       FILE *file = ptr;
5869
5870       /* xgettext:c-format */
5871       fprintf (file, _("private flags = 0x%lx:"),
5872                elf_elfheader (abfd)->e_flags);
5873
5874       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5875         fprintf (file, _(" [abiv%ld]"),
5876                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5877       fputc ('\n', file);
5878     }
5879
5880   return TRUE;
5881 }
5882
5883 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5884    of the code entry point, and its section.  */
5885
5886 static bfd_vma
5887 opd_entry_value (asection *opd_sec,
5888                  bfd_vma offset,
5889                  asection **code_sec,
5890                  bfd_vma *code_off,
5891                  bfd_boolean in_code_sec)
5892 {
5893   bfd *opd_bfd = opd_sec->owner;
5894   Elf_Internal_Rela *relocs;
5895   Elf_Internal_Rela *lo, *hi, *look;
5896   bfd_vma val;
5897
5898   /* No relocs implies we are linking a --just-symbols object, or looking
5899      at a final linked executable with addr2line or somesuch.  */
5900   if (opd_sec->reloc_count == 0)
5901     {
5902       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5903
5904       if (contents == NULL)
5905         {
5906           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5907             return (bfd_vma) -1;
5908           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5909         }
5910
5911       val = bfd_get_64 (opd_bfd, contents + offset);
5912       if (code_sec != NULL)
5913         {
5914           asection *sec, *likely = NULL;
5915
5916           if (in_code_sec)
5917             {
5918               sec = *code_sec;
5919               if (sec->vma <= val
5920                   && val < sec->vma + sec->size)
5921                 likely = sec;
5922               else
5923                 val = -1;
5924             }
5925           else
5926             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5927               if (sec->vma <= val
5928                   && (sec->flags & SEC_LOAD) != 0
5929                   && (sec->flags & SEC_ALLOC) != 0)
5930                 likely = sec;
5931           if (likely != NULL)
5932             {
5933               *code_sec = likely;
5934               if (code_off != NULL)
5935                 *code_off = val - likely->vma;
5936             }
5937         }
5938       return val;
5939     }
5940
5941   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5942
5943   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5944   if (relocs == NULL)
5945     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5946
5947   /* Go find the opd reloc at the sym address.  */
5948   lo = relocs;
5949   BFD_ASSERT (lo != NULL);
5950   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5951   val = (bfd_vma) -1;
5952   while (lo < hi)
5953     {
5954       look = lo + (hi - lo) / 2;
5955       if (look->r_offset < offset)
5956         lo = look + 1;
5957       else if (look->r_offset > offset)
5958         hi = look;
5959       else
5960         {
5961           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5962
5963           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5964               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5965             {
5966               unsigned long symndx = ELF64_R_SYM (look->r_info);
5967               asection *sec;
5968
5969               if (symndx < symtab_hdr->sh_info
5970                   || elf_sym_hashes (opd_bfd) == NULL)
5971                 {
5972                   Elf_Internal_Sym *sym;
5973
5974                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5975                   if (sym == NULL)
5976                     {
5977                       size_t symcnt = symtab_hdr->sh_info;
5978                       if (elf_sym_hashes (opd_bfd) == NULL)
5979                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5980                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5981                                                   0, NULL, NULL, NULL);
5982                       if (sym == NULL)
5983                         break;
5984                       symtab_hdr->contents = (bfd_byte *) sym;
5985                     }
5986
5987                   sym += symndx;
5988                   val = sym->st_value;
5989                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5990                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5991                 }
5992               else
5993                 {
5994                   struct elf_link_hash_entry **sym_hashes;
5995                   struct elf_link_hash_entry *rh;
5996
5997                   sym_hashes = elf_sym_hashes (opd_bfd);
5998                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5999                   if (rh != NULL)
6000                     {
6001                       rh = elf_follow_link (rh);
6002                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6003                                   || rh->root.type == bfd_link_hash_defweak);
6004                       val = rh->root.u.def.value;
6005                       sec = rh->root.u.def.section;
6006                     }
6007                   else
6008                     {
6009                       /* Handle the odd case where we can be called
6010                          during bfd_elf_link_add_symbols before the
6011                          symbol hashes have been fully populated.  */
6012                       Elf_Internal_Sym *sym;
6013
6014                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6015                                                   symndx, NULL, NULL, NULL);
6016                       if (sym == NULL)
6017                         break;
6018
6019                       val = sym->st_value;
6020                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6021                       free (sym);
6022                     }
6023                 }
6024               val += look->r_addend;
6025               if (code_off != NULL)
6026                 *code_off = val;
6027               if (code_sec != NULL)
6028                 {
6029                   if (in_code_sec && *code_sec != sec)
6030                     return -1;
6031                   else
6032                     *code_sec = sec;
6033                 }
6034               if (sec != NULL && sec->output_section != NULL)
6035                 val += sec->output_section->vma + sec->output_offset;
6036             }
6037           break;
6038         }
6039     }
6040
6041   return val;
6042 }
6043
6044 /* If the ELF symbol SYM might be a function in SEC, return the
6045    function size and set *CODE_OFF to the function's entry point,
6046    otherwise return zero.  */
6047
6048 static bfd_size_type
6049 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6050                               bfd_vma *code_off)
6051 {
6052   bfd_size_type size;
6053
6054   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6055                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6056     return 0;
6057
6058   size = 0;
6059   if (!(sym->flags & BSF_SYNTHETIC))
6060     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6061
6062   if (strcmp (sym->section->name, ".opd") == 0)
6063     {
6064       if (opd_entry_value (sym->section, sym->value,
6065                            &sec, code_off, TRUE) == (bfd_vma) -1)
6066         return 0;
6067       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6068          symbol.  This size has nothing to do with the code size of the
6069          function, which is what we're supposed to return, but the
6070          code size isn't available without looking up the dot-sym.
6071          However, doing that would be a waste of time particularly
6072          since elf_find_function will look at the dot-sym anyway.
6073          Now, elf_find_function will keep the largest size of any
6074          function sym found at the code address of interest, so return
6075          1 here to avoid it incorrectly caching a larger function size
6076          for a small function.  This does mean we return the wrong
6077          size for a new-ABI function of size 24, but all that does is
6078          disable caching for such functions.  */
6079       if (size == 24)
6080         size = 1;
6081     }
6082   else
6083     {
6084       if (sym->section != sec)
6085         return 0;
6086       *code_off = sym->value;
6087     }
6088   if (size == 0)
6089     size = 1;
6090   return size;
6091 }
6092
6093 /* Return true if symbol is defined in a regular object file.  */
6094
6095 static bfd_boolean
6096 is_static_defined (struct elf_link_hash_entry *h)
6097 {
6098   return ((h->root.type == bfd_link_hash_defined
6099            || h->root.type == bfd_link_hash_defweak)
6100           && h->root.u.def.section != NULL
6101           && h->root.u.def.section->output_section != NULL);
6102 }
6103
6104 /* If FDH is a function descriptor symbol, return the associated code
6105    entry symbol if it is defined.  Return NULL otherwise.  */
6106
6107 static struct ppc_link_hash_entry *
6108 defined_code_entry (struct ppc_link_hash_entry *fdh)
6109 {
6110   if (fdh->is_func_descriptor)
6111     {
6112       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6113       if (fh->elf.root.type == bfd_link_hash_defined
6114           || fh->elf.root.type == bfd_link_hash_defweak)
6115         return fh;
6116     }
6117   return NULL;
6118 }
6119
6120 /* If FH is a function code entry symbol, return the associated
6121    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6122
6123 static struct ppc_link_hash_entry *
6124 defined_func_desc (struct ppc_link_hash_entry *fh)
6125 {
6126   if (fh->oh != NULL
6127       && fh->oh->is_func_descriptor)
6128     {
6129       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6130       if (fdh->elf.root.type == bfd_link_hash_defined
6131           || fdh->elf.root.type == bfd_link_hash_defweak)
6132         return fdh;
6133     }
6134   return NULL;
6135 }
6136
6137 /* Mark all our entry sym sections, both opd and code section.  */
6138
6139 static void
6140 ppc64_elf_gc_keep (struct bfd_link_info *info)
6141 {
6142   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6143   struct bfd_sym_chain *sym;
6144
6145   if (htab == NULL)
6146     return;
6147
6148   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6149     {
6150       struct ppc_link_hash_entry *eh, *fh;
6151       asection *sec;
6152
6153       eh = (struct ppc_link_hash_entry *)
6154         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6155       if (eh == NULL)
6156         continue;
6157       if (eh->elf.root.type != bfd_link_hash_defined
6158           && eh->elf.root.type != bfd_link_hash_defweak)
6159         continue;
6160
6161       fh = defined_code_entry (eh);
6162       if (fh != NULL)
6163         {
6164           sec = fh->elf.root.u.def.section;
6165           sec->flags |= SEC_KEEP;
6166         }
6167       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6168                && opd_entry_value (eh->elf.root.u.def.section,
6169                                    eh->elf.root.u.def.value,
6170                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6171         sec->flags |= SEC_KEEP;
6172
6173       sec = eh->elf.root.u.def.section;
6174       sec->flags |= SEC_KEEP;
6175     }
6176 }
6177
6178 /* Mark sections containing dynamically referenced symbols.  When
6179    building shared libraries, we must assume that any visible symbol is
6180    referenced.  */
6181
6182 static bfd_boolean
6183 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6184 {
6185   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6186   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6187   struct ppc_link_hash_entry *fdh;
6188   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6189
6190   /* Dynamic linking info is on the func descriptor sym.  */
6191   fdh = defined_func_desc (eh);
6192   if (fdh != NULL)
6193     eh = fdh;
6194
6195   if ((eh->elf.root.type == bfd_link_hash_defined
6196        || eh->elf.root.type == bfd_link_hash_defweak)
6197       && (eh->elf.ref_dynamic
6198           || (eh->elf.def_regular
6199               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6200               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6201               && (!info->executable
6202                   || info->export_dynamic
6203                   || (eh->elf.dynamic
6204                       && d != NULL
6205                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6206               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6207                   || !bfd_hide_sym_by_version (info->version_info,
6208                                                eh->elf.root.root.string)))))
6209     {
6210       asection *code_sec;
6211       struct ppc_link_hash_entry *fh;
6212
6213       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6214
6215       /* Function descriptor syms cause the associated
6216          function code sym section to be marked.  */
6217       fh = defined_code_entry (eh);
6218       if (fh != NULL)
6219         {
6220           code_sec = fh->elf.root.u.def.section;
6221           code_sec->flags |= SEC_KEEP;
6222         }
6223       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6224                && opd_entry_value (eh->elf.root.u.def.section,
6225                                    eh->elf.root.u.def.value,
6226                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6227         code_sec->flags |= SEC_KEEP;
6228     }
6229
6230   return TRUE;
6231 }
6232
6233 /* Return the section that should be marked against GC for a given
6234    relocation.  */
6235
6236 static asection *
6237 ppc64_elf_gc_mark_hook (asection *sec,
6238                         struct bfd_link_info *info,
6239                         Elf_Internal_Rela *rel,
6240                         struct elf_link_hash_entry *h,
6241                         Elf_Internal_Sym *sym)
6242 {
6243   asection *rsec;
6244
6245   /* Syms return NULL if we're marking .opd, so we avoid marking all
6246      function sections, as all functions are referenced in .opd.  */
6247   rsec = NULL;
6248   if (get_opd_info (sec) != NULL)
6249     return rsec;
6250
6251   if (h != NULL)
6252     {
6253       enum elf_ppc64_reloc_type r_type;
6254       struct ppc_link_hash_entry *eh, *fh, *fdh;
6255
6256       r_type = ELF64_R_TYPE (rel->r_info);
6257       switch (r_type)
6258         {
6259         case R_PPC64_GNU_VTINHERIT:
6260         case R_PPC64_GNU_VTENTRY:
6261           break;
6262
6263         default:
6264           switch (h->root.type)
6265             {
6266             case bfd_link_hash_defined:
6267             case bfd_link_hash_defweak:
6268               eh = (struct ppc_link_hash_entry *) h;
6269               fdh = defined_func_desc (eh);
6270               if (fdh != NULL)
6271                 eh = fdh;
6272
6273               /* Function descriptor syms cause the associated
6274                  function code sym section to be marked.  */
6275               fh = defined_code_entry (eh);
6276               if (fh != NULL)
6277                 {
6278                   /* They also mark their opd section.  */
6279                   eh->elf.root.u.def.section->gc_mark = 1;
6280
6281                   rsec = fh->elf.root.u.def.section;
6282                 }
6283               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6284                        && opd_entry_value (eh->elf.root.u.def.section,
6285                                            eh->elf.root.u.def.value,
6286                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6287                 eh->elf.root.u.def.section->gc_mark = 1;
6288               else
6289                 rsec = h->root.u.def.section;
6290               break;
6291
6292             case bfd_link_hash_common:
6293               rsec = h->root.u.c.p->section;
6294               break;
6295
6296             default:
6297               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6298             }
6299         }
6300     }
6301   else
6302     {
6303       struct _opd_sec_data *opd;
6304
6305       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6306       opd = get_opd_info (rsec);
6307       if (opd != NULL && opd->func_sec != NULL)
6308         {
6309           rsec->gc_mark = 1;
6310
6311           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6312         }
6313     }
6314
6315   return rsec;
6316 }
6317
6318 /* Update the .got, .plt. and dynamic reloc reference counts for the
6319    section being removed.  */
6320
6321 static bfd_boolean
6322 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6323                          asection *sec, const Elf_Internal_Rela *relocs)
6324 {
6325   struct ppc_link_hash_table *htab;
6326   Elf_Internal_Shdr *symtab_hdr;
6327   struct elf_link_hash_entry **sym_hashes;
6328   struct got_entry **local_got_ents;
6329   const Elf_Internal_Rela *rel, *relend;
6330
6331   if (info->relocatable)
6332     return TRUE;
6333
6334   if ((sec->flags & SEC_ALLOC) == 0)
6335     return TRUE;
6336
6337   elf_section_data (sec)->local_dynrel = NULL;
6338
6339   htab = ppc_hash_table (info);
6340   if (htab == NULL)
6341     return FALSE;
6342
6343   symtab_hdr = &elf_symtab_hdr (abfd);
6344   sym_hashes = elf_sym_hashes (abfd);
6345   local_got_ents = elf_local_got_ents (abfd);
6346
6347   relend = relocs + sec->reloc_count;
6348   for (rel = relocs; rel < relend; rel++)
6349     {
6350       unsigned long r_symndx;
6351       enum elf_ppc64_reloc_type r_type;
6352       struct elf_link_hash_entry *h = NULL;
6353       unsigned char tls_type = 0;
6354
6355       r_symndx = ELF64_R_SYM (rel->r_info);
6356       r_type = ELF64_R_TYPE (rel->r_info);
6357       if (r_symndx >= symtab_hdr->sh_info)
6358         {
6359           struct ppc_link_hash_entry *eh;
6360           struct elf_dyn_relocs **pp;
6361           struct elf_dyn_relocs *p;
6362
6363           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6364           h = elf_follow_link (h);
6365           eh = (struct ppc_link_hash_entry *) h;
6366
6367           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6368             if (p->sec == sec)
6369               {
6370                 /* Everything must go for SEC.  */
6371                 *pp = p->next;
6372                 break;
6373               }
6374         }
6375
6376       if (is_branch_reloc (r_type))
6377         {
6378           struct plt_entry **ifunc = NULL;
6379           if (h != NULL)
6380             {
6381               if (h->type == STT_GNU_IFUNC)
6382                 ifunc = &h->plt.plist;
6383             }
6384           else if (local_got_ents != NULL)
6385             {
6386               struct plt_entry **local_plt = (struct plt_entry **)
6387                 (local_got_ents + symtab_hdr->sh_info);
6388               unsigned char *local_got_tls_masks = (unsigned char *)
6389                 (local_plt + symtab_hdr->sh_info);
6390               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6391                 ifunc = local_plt + r_symndx;
6392             }
6393           if (ifunc != NULL)
6394             {
6395               struct plt_entry *ent;
6396
6397               for (ent = *ifunc; ent != NULL; ent = ent->next)
6398                 if (ent->addend == rel->r_addend)
6399                   break;
6400               if (ent == NULL)
6401                 abort ();
6402               if (ent->plt.refcount > 0)
6403                 ent->plt.refcount -= 1;
6404               continue;
6405             }
6406         }
6407
6408       switch (r_type)
6409         {
6410         case R_PPC64_GOT_TLSLD16:
6411         case R_PPC64_GOT_TLSLD16_LO:
6412         case R_PPC64_GOT_TLSLD16_HI:
6413         case R_PPC64_GOT_TLSLD16_HA:
6414           tls_type = TLS_TLS | TLS_LD;
6415           goto dogot;
6416
6417         case R_PPC64_GOT_TLSGD16:
6418         case R_PPC64_GOT_TLSGD16_LO:
6419         case R_PPC64_GOT_TLSGD16_HI:
6420         case R_PPC64_GOT_TLSGD16_HA:
6421           tls_type = TLS_TLS | TLS_GD;
6422           goto dogot;
6423
6424         case R_PPC64_GOT_TPREL16_DS:
6425         case R_PPC64_GOT_TPREL16_LO_DS:
6426         case R_PPC64_GOT_TPREL16_HI:
6427         case R_PPC64_GOT_TPREL16_HA:
6428           tls_type = TLS_TLS | TLS_TPREL;
6429           goto dogot;
6430
6431         case R_PPC64_GOT_DTPREL16_DS:
6432         case R_PPC64_GOT_DTPREL16_LO_DS:
6433         case R_PPC64_GOT_DTPREL16_HI:
6434         case R_PPC64_GOT_DTPREL16_HA:
6435           tls_type = TLS_TLS | TLS_DTPREL;
6436           goto dogot;
6437
6438         case R_PPC64_GOT16:
6439         case R_PPC64_GOT16_DS:
6440         case R_PPC64_GOT16_HA:
6441         case R_PPC64_GOT16_HI:
6442         case R_PPC64_GOT16_LO:
6443         case R_PPC64_GOT16_LO_DS:
6444         dogot:
6445           {
6446             struct got_entry *ent;
6447
6448             if (h != NULL)
6449               ent = h->got.glist;
6450             else
6451               ent = local_got_ents[r_symndx];
6452
6453             for (; ent != NULL; ent = ent->next)
6454               if (ent->addend == rel->r_addend
6455                   && ent->owner == abfd
6456                   && ent->tls_type == tls_type)
6457                 break;
6458             if (ent == NULL)
6459               abort ();
6460             if (ent->got.refcount > 0)
6461               ent->got.refcount -= 1;
6462           }
6463           break;
6464
6465         case R_PPC64_PLT16_HA:
6466         case R_PPC64_PLT16_HI:
6467         case R_PPC64_PLT16_LO:
6468         case R_PPC64_PLT32:
6469         case R_PPC64_PLT64:
6470         case R_PPC64_REL14:
6471         case R_PPC64_REL14_BRNTAKEN:
6472         case R_PPC64_REL14_BRTAKEN:
6473         case R_PPC64_REL24:
6474           if (h != NULL)
6475             {
6476               struct plt_entry *ent;
6477
6478               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6479                 if (ent->addend == rel->r_addend)
6480                   break;
6481               if (ent != NULL && ent->plt.refcount > 0)
6482                 ent->plt.refcount -= 1;
6483             }
6484           break;
6485
6486         default:
6487           break;
6488         }
6489     }
6490   return TRUE;
6491 }
6492
6493 /* The maximum size of .sfpr.  */
6494 #define SFPR_MAX (218*4)
6495
6496 struct sfpr_def_parms
6497 {
6498   const char name[12];
6499   unsigned char lo, hi;
6500   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6501   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6502 };
6503
6504 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6505
6506 static bfd_boolean
6507 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6508 {
6509   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6510   unsigned int i;
6511   size_t len = strlen (parm->name);
6512   bfd_boolean writing = FALSE;
6513   char sym[16];
6514
6515   if (htab == NULL)
6516     return FALSE;
6517
6518   memcpy (sym, parm->name, len);
6519   sym[len + 2] = 0;
6520
6521   for (i = parm->lo; i <= parm->hi; i++)
6522     {
6523       struct elf_link_hash_entry *h;
6524
6525       sym[len + 0] = i / 10 + '0';
6526       sym[len + 1] = i % 10 + '0';
6527       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6528       if (h != NULL
6529           && !h->def_regular)
6530         {
6531           h->root.type = bfd_link_hash_defined;
6532           h->root.u.def.section = htab->sfpr;
6533           h->root.u.def.value = htab->sfpr->size;
6534           h->type = STT_FUNC;
6535           h->def_regular = 1;
6536           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6537           writing = TRUE;
6538           if (htab->sfpr->contents == NULL)
6539             {
6540               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6541               if (htab->sfpr->contents == NULL)
6542                 return FALSE;
6543             }
6544         }
6545       if (writing)
6546         {
6547           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6548           if (i != parm->hi)
6549             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6550           else
6551             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6552           htab->sfpr->size = p - htab->sfpr->contents;
6553         }
6554     }
6555
6556   return TRUE;
6557 }
6558
6559 static bfd_byte *
6560 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6561 {
6562   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6563   return p + 4;
6564 }
6565
6566 static bfd_byte *
6567 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6568 {
6569   p = savegpr0 (abfd, p, r);
6570   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6571   p = p + 4;
6572   bfd_put_32 (abfd, BLR, p);
6573   return p + 4;
6574 }
6575
6576 static bfd_byte *
6577 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6578 {
6579   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6580   return p + 4;
6581 }
6582
6583 static bfd_byte *
6584 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6585 {
6586   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6587   p = p + 4;
6588   p = restgpr0 (abfd, p, r);
6589   bfd_put_32 (abfd, MTLR_R0, p);
6590   p = p + 4;
6591   if (r == 29)
6592     {
6593       p = restgpr0 (abfd, p, 30);
6594       p = restgpr0 (abfd, p, 31);
6595     }
6596   bfd_put_32 (abfd, BLR, p);
6597   return p + 4;
6598 }
6599
6600 static bfd_byte *
6601 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6602 {
6603   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6604   return p + 4;
6605 }
6606
6607 static bfd_byte *
6608 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6609 {
6610   p = savegpr1 (abfd, p, r);
6611   bfd_put_32 (abfd, BLR, p);
6612   return p + 4;
6613 }
6614
6615 static bfd_byte *
6616 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6617 {
6618   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6619   return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   p = restgpr1 (abfd, p, r);
6626   bfd_put_32 (abfd, BLR, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 savefpr (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6634   return p + 4;
6635 }
6636
6637 static bfd_byte *
6638 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6639 {
6640   p = savefpr (abfd, p, r);
6641   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6642   p = p + 4;
6643   bfd_put_32 (abfd, BLR, p);
6644   return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 restfpr (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6651   return p + 4;
6652 }
6653
6654 static bfd_byte *
6655 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6656 {
6657   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6658   p = p + 4;
6659   p = restfpr (abfd, p, r);
6660   bfd_put_32 (abfd, MTLR_R0, p);
6661   p = p + 4;
6662   if (r == 29)
6663     {
6664       p = restfpr (abfd, p, 30);
6665       p = restfpr (abfd, p, 31);
6666     }
6667   bfd_put_32 (abfd, BLR, p);
6668   return p + 4;
6669 }
6670
6671 static bfd_byte *
6672 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6673 {
6674   p = savefpr (abfd, p, r);
6675   bfd_put_32 (abfd, BLR, p);
6676   return p + 4;
6677 }
6678
6679 static bfd_byte *
6680 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6681 {
6682   p = restfpr (abfd, p, r);
6683   bfd_put_32 (abfd, BLR, p);
6684   return p + 4;
6685 }
6686
6687 static bfd_byte *
6688 savevr (bfd *abfd, bfd_byte *p, int r)
6689 {
6690   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6691   p = p + 4;
6692   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6693   return p + 4;
6694 }
6695
6696 static bfd_byte *
6697 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6698 {
6699   p = savevr (abfd, p, r);
6700   bfd_put_32 (abfd, BLR, p);
6701   return p + 4;
6702 }
6703
6704 static bfd_byte *
6705 restvr (bfd *abfd, bfd_byte *p, int r)
6706 {
6707   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6708   p = p + 4;
6709   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6710   return p + 4;
6711 }
6712
6713 static bfd_byte *
6714 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6715 {
6716   p = restvr (abfd, p, r);
6717   bfd_put_32 (abfd, BLR, p);
6718   return p + 4;
6719 }
6720
6721 /* Called via elf_link_hash_traverse to transfer dynamic linking
6722    information on function code symbol entries to their corresponding
6723    function descriptor symbol entries.  */
6724
6725 static bfd_boolean
6726 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6727 {
6728   struct bfd_link_info *info;
6729   struct ppc_link_hash_table *htab;
6730   struct plt_entry *ent;
6731   struct ppc_link_hash_entry *fh;
6732   struct ppc_link_hash_entry *fdh;
6733   bfd_boolean force_local;
6734
6735   fh = (struct ppc_link_hash_entry *) h;
6736   if (fh->elf.root.type == bfd_link_hash_indirect)
6737     return TRUE;
6738
6739   info = inf;
6740   htab = ppc_hash_table (info);
6741   if (htab == NULL)
6742     return FALSE;
6743
6744   /* Resolve undefined references to dot-symbols as the value
6745      in the function descriptor, if we have one in a regular object.
6746      This is to satisfy cases like ".quad .foo".  Calls to functions
6747      in dynamic objects are handled elsewhere.  */
6748   if (fh->elf.root.type == bfd_link_hash_undefweak
6749       && fh->was_undefined
6750       && (fdh = defined_func_desc (fh)) != NULL
6751       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6752       && opd_entry_value (fdh->elf.root.u.def.section,
6753                           fdh->elf.root.u.def.value,
6754                           &fh->elf.root.u.def.section,
6755                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6756     {
6757       fh->elf.root.type = fdh->elf.root.type;
6758       fh->elf.forced_local = 1;
6759       fh->elf.def_regular = fdh->elf.def_regular;
6760       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6761     }
6762
6763   /* If this is a function code symbol, transfer dynamic linking
6764      information to the function descriptor symbol.  */
6765   if (!fh->is_func)
6766     return TRUE;
6767
6768   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6769     if (ent->plt.refcount > 0)
6770       break;
6771   if (ent == NULL
6772       || fh->elf.root.root.string[0] != '.'
6773       || fh->elf.root.root.string[1] == '\0')
6774     return TRUE;
6775
6776   /* Find the corresponding function descriptor symbol.  Create it
6777      as undefined if necessary.  */
6778
6779   fdh = lookup_fdh (fh, htab);
6780   if (fdh == NULL
6781       && !info->executable
6782       && (fh->elf.root.type == bfd_link_hash_undefined
6783           || fh->elf.root.type == bfd_link_hash_undefweak))
6784     {
6785       fdh = make_fdh (info, fh);
6786       if (fdh == NULL)
6787         return FALSE;
6788     }
6789
6790   /* Fake function descriptors are made undefweak.  If the function
6791      code symbol is strong undefined, make the fake sym the same.
6792      If the function code symbol is defined, then force the fake
6793      descriptor local;  We can't support overriding of symbols in a
6794      shared library on a fake descriptor.  */
6795
6796   if (fdh != NULL
6797       && fdh->fake
6798       && fdh->elf.root.type == bfd_link_hash_undefweak)
6799     {
6800       if (fh->elf.root.type == bfd_link_hash_undefined)
6801         {
6802           fdh->elf.root.type = bfd_link_hash_undefined;
6803           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6804         }
6805       else if (fh->elf.root.type == bfd_link_hash_defined
6806                || fh->elf.root.type == bfd_link_hash_defweak)
6807         {
6808           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6809         }
6810     }
6811
6812   if (fdh != NULL
6813       && !fdh->elf.forced_local
6814       && (!info->executable
6815           || fdh->elf.def_dynamic
6816           || fdh->elf.ref_dynamic
6817           || (fdh->elf.root.type == bfd_link_hash_undefweak
6818               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6819     {
6820       if (fdh->elf.dynindx == -1)
6821         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6822           return FALSE;
6823       fdh->elf.ref_regular |= fh->elf.ref_regular;
6824       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6825       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6826       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6827       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6828         {
6829           move_plt_plist (fh, fdh);
6830           fdh->elf.needs_plt = 1;
6831         }
6832       fdh->is_func_descriptor = 1;
6833       fdh->oh = fh;
6834       fh->oh = fdh;
6835     }
6836
6837   /* Now that the info is on the function descriptor, clear the
6838      function code sym info.  Any function code syms for which we
6839      don't have a definition in a regular file, we force local.
6840      This prevents a shared library from exporting syms that have
6841      been imported from another library.  Function code syms that
6842      are really in the library we must leave global to prevent the
6843      linker dragging in a definition from a static library.  */
6844   force_local = (!fh->elf.def_regular
6845                  || fdh == NULL
6846                  || !fdh->elf.def_regular
6847                  || fdh->elf.forced_local);
6848   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6849
6850   return TRUE;
6851 }
6852
6853 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6854    this hook to a) provide some gcc support functions, and b) transfer
6855    dynamic linking information gathered so far on function code symbol
6856    entries, to their corresponding function descriptor symbol entries.  */
6857
6858 static bfd_boolean
6859 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6860                             struct bfd_link_info *info)
6861 {
6862   struct ppc_link_hash_table *htab;
6863   unsigned int i;
6864   static const struct sfpr_def_parms funcs[] =
6865     {
6866       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6867       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6868       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6869       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6870       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6871       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6872       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6873       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6874       { "._savef", 14, 31, savefpr, savefpr1_tail },
6875       { "._restf", 14, 31, restfpr, restfpr1_tail },
6876       { "_savevr_", 20, 31, savevr, savevr_tail },
6877       { "_restvr_", 20, 31, restvr, restvr_tail }
6878     };
6879
6880   htab = ppc_hash_table (info);
6881   if (htab == NULL)
6882     return FALSE;
6883
6884   if (!info->relocatable
6885       && htab->elf.hgot != NULL)
6886     {
6887       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6888       /* Make .TOC. defined so as to prevent it being made dynamic.
6889          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6890       htab->elf.hgot->type = STT_OBJECT;
6891       htab->elf.hgot->root.type = bfd_link_hash_defined;
6892       htab->elf.hgot->root.u.def.value = 0;
6893       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6894       htab->elf.hgot->def_regular = 1;
6895       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6896                                | STV_HIDDEN);
6897     }
6898
6899   if (htab->sfpr == NULL)
6900     /* We don't have any relocs.  */
6901     return TRUE;
6902
6903   /* Provide any missing _save* and _rest* functions.  */
6904   htab->sfpr->size = 0;
6905   if (htab->params->save_restore_funcs)
6906     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6907       if (!sfpr_define (info, &funcs[i]))
6908         return FALSE;
6909
6910   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6911
6912   if (htab->sfpr->size == 0)
6913     htab->sfpr->flags |= SEC_EXCLUDE;
6914
6915   return TRUE;
6916 }
6917
6918 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6919
6920 static bfd_boolean
6921 readonly_dynrelocs (struct elf_link_hash_entry *h)
6922 {
6923   struct ppc_link_hash_entry *eh;
6924   struct elf_dyn_relocs *p;
6925
6926   eh = (struct ppc_link_hash_entry *) h;
6927   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6928     {
6929       asection *s = p->sec->output_section;
6930
6931       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6932         return TRUE;
6933     }
6934   return FALSE;
6935 }
6936
6937 /* Adjust a symbol defined by a dynamic object and referenced by a
6938    regular object.  The current definition is in some section of the
6939    dynamic object, but we're not including those sections.  We have to
6940    change the definition to something the rest of the link can
6941    understand.  */
6942
6943 static bfd_boolean
6944 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6945                                  struct elf_link_hash_entry *h)
6946 {
6947   struct ppc_link_hash_table *htab;
6948   asection *s;
6949
6950   htab = ppc_hash_table (info);
6951   if (htab == NULL)
6952     return FALSE;
6953
6954   /* Deal with function syms.  */
6955   if (h->type == STT_FUNC
6956       || h->type == STT_GNU_IFUNC
6957       || h->needs_plt)
6958     {
6959       /* Clear procedure linkage table information for any symbol that
6960          won't need a .plt entry.  */
6961       struct plt_entry *ent;
6962       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6963         if (ent->plt.refcount > 0)
6964           break;
6965       if (ent == NULL
6966           || (h->type != STT_GNU_IFUNC
6967               && (SYMBOL_CALLS_LOCAL (info, h)
6968                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6969                       && h->root.type == bfd_link_hash_undefweak))))
6970         {
6971           h->plt.plist = NULL;
6972           h->needs_plt = 0;
6973         }
6974       else if (abiversion (info->output_bfd) == 2)
6975         {
6976           /* After adjust_dynamic_symbol, non_got_ref set in the
6977              non-shared case means that we have allocated space in
6978              .dynbss for the symbol and thus dyn_relocs for this
6979              symbol should be discarded.
6980              If we get here we know we are making a PLT entry for this
6981              symbol, and in an executable we'd normally resolve
6982              relocations against this symbol to the PLT entry.  Allow
6983              dynamic relocs if the reference is weak, and the dynamic
6984              relocs will not cause text relocation.  */
6985           if (!h->ref_regular_nonweak
6986               && h->non_got_ref
6987               && h->type != STT_GNU_IFUNC
6988               && !readonly_dynrelocs (h))
6989             h->non_got_ref = 0;
6990
6991           /* If making a plt entry, then we don't need copy relocs.  */
6992           return TRUE;
6993         }
6994     }
6995   else
6996     h->plt.plist = NULL;
6997
6998   /* If this is a weak symbol, and there is a real definition, the
6999      processor independent code will have arranged for us to see the
7000      real definition first, and we can just use the same value.  */
7001   if (h->u.weakdef != NULL)
7002     {
7003       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7004                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7005       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7006       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7007       if (ELIMINATE_COPY_RELOCS)
7008         h->non_got_ref = h->u.weakdef->non_got_ref;
7009       return TRUE;
7010     }
7011
7012   /* If we are creating a shared library, we must presume that the
7013      only references to the symbol are via the global offset table.
7014      For such cases we need not do anything here; the relocations will
7015      be handled correctly by relocate_section.  */
7016   if (info->shared)
7017     return TRUE;
7018
7019   /* If there are no references to this symbol that do not use the
7020      GOT, we don't need to generate a copy reloc.  */
7021   if (!h->non_got_ref)
7022     return TRUE;
7023
7024   /* Don't generate a copy reloc for symbols defined in the executable.  */
7025   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7026     return TRUE;
7027
7028   /* If we didn't find any dynamic relocs in read-only sections, then
7029      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7030   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7031     {
7032       h->non_got_ref = 0;
7033       return TRUE;
7034     }
7035
7036   if (h->plt.plist != NULL)
7037     {
7038       /* We should never get here, but unfortunately there are versions
7039          of gcc out there that improperly (for this ABI) put initialized
7040          function pointers, vtable refs and suchlike in read-only
7041          sections.  Allow them to proceed, but warn that this might
7042          break at runtime.  */
7043       info->callbacks->einfo
7044         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7045            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7046          h->root.root.string);
7047     }
7048
7049   /* This is a reference to a symbol defined by a dynamic object which
7050      is not a function.  */
7051
7052   /* We must allocate the symbol in our .dynbss section, which will
7053      become part of the .bss section of the executable.  There will be
7054      an entry for this symbol in the .dynsym section.  The dynamic
7055      object will contain position independent code, so all references
7056      from the dynamic object to this symbol will go through the global
7057      offset table.  The dynamic linker will use the .dynsym entry to
7058      determine the address it must put in the global offset table, so
7059      both the dynamic object and the regular object will refer to the
7060      same memory location for the variable.  */
7061
7062   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7063      to copy the initial value out of the dynamic object and into the
7064      runtime process image.  We need to remember the offset into the
7065      .rela.bss section we are going to use.  */
7066   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7067     {
7068       htab->relbss->size += sizeof (Elf64_External_Rela);
7069       h->needs_copy = 1;
7070     }
7071
7072   s = htab->dynbss;
7073
7074   return _bfd_elf_adjust_dynamic_copy (h, s);
7075 }
7076
7077 /* If given a function descriptor symbol, hide both the function code
7078    sym and the descriptor.  */
7079 static void
7080 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7081                        struct elf_link_hash_entry *h,
7082                        bfd_boolean force_local)
7083 {
7084   struct ppc_link_hash_entry *eh;
7085   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7086
7087   eh = (struct ppc_link_hash_entry *) h;
7088   if (eh->is_func_descriptor)
7089     {
7090       struct ppc_link_hash_entry *fh = eh->oh;
7091
7092       if (fh == NULL)
7093         {
7094           const char *p, *q;
7095           struct ppc_link_hash_table *htab;
7096           char save;
7097
7098           /* We aren't supposed to use alloca in BFD because on
7099              systems which do not have alloca the version in libiberty
7100              calls xmalloc, which might cause the program to crash
7101              when it runs out of memory.  This function doesn't have a
7102              return status, so there's no way to gracefully return an
7103              error.  So cheat.  We know that string[-1] can be safely
7104              accessed;  It's either a string in an ELF string table,
7105              or allocated in an objalloc structure.  */
7106
7107           p = eh->elf.root.root.string - 1;
7108           save = *p;
7109           *(char *) p = '.';
7110           htab = ppc_hash_table (info);
7111           if (htab == NULL)
7112             return;
7113
7114           fh = (struct ppc_link_hash_entry *)
7115             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7116           *(char *) p = save;
7117
7118           /* Unfortunately, if it so happens that the string we were
7119              looking for was allocated immediately before this string,
7120              then we overwrote the string terminator.  That's the only
7121              reason the lookup should fail.  */
7122           if (fh == NULL)
7123             {
7124               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7125               while (q >= eh->elf.root.root.string && *q == *p)
7126                 --q, --p;
7127               if (q < eh->elf.root.root.string && *p == '.')
7128                 fh = (struct ppc_link_hash_entry *)
7129                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7130             }
7131           if (fh != NULL)
7132             {
7133               eh->oh = fh;
7134               fh->oh = eh;
7135             }
7136         }
7137       if (fh != NULL)
7138         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7139     }
7140 }
7141
7142 static bfd_boolean
7143 get_sym_h (struct elf_link_hash_entry **hp,
7144            Elf_Internal_Sym **symp,
7145            asection **symsecp,
7146            unsigned char **tls_maskp,
7147            Elf_Internal_Sym **locsymsp,
7148            unsigned long r_symndx,
7149            bfd *ibfd)
7150 {
7151   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7152
7153   if (r_symndx >= symtab_hdr->sh_info)
7154     {
7155       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7156       struct elf_link_hash_entry *h;
7157
7158       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7159       h = elf_follow_link (h);
7160
7161       if (hp != NULL)
7162         *hp = h;
7163
7164       if (symp != NULL)
7165         *symp = NULL;
7166
7167       if (symsecp != NULL)
7168         {
7169           asection *symsec = NULL;
7170           if (h->root.type == bfd_link_hash_defined
7171               || h->root.type == bfd_link_hash_defweak)
7172             symsec = h->root.u.def.section;
7173           *symsecp = symsec;
7174         }
7175
7176       if (tls_maskp != NULL)
7177         {
7178           struct ppc_link_hash_entry *eh;
7179
7180           eh = (struct ppc_link_hash_entry *) h;
7181           *tls_maskp = &eh->tls_mask;
7182         }
7183     }
7184   else
7185     {
7186       Elf_Internal_Sym *sym;
7187       Elf_Internal_Sym *locsyms = *locsymsp;
7188
7189       if (locsyms == NULL)
7190         {
7191           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7192           if (locsyms == NULL)
7193             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7194                                             symtab_hdr->sh_info,
7195                                             0, NULL, NULL, NULL);
7196           if (locsyms == NULL)
7197             return FALSE;
7198           *locsymsp = locsyms;
7199         }
7200       sym = locsyms + r_symndx;
7201
7202       if (hp != NULL)
7203         *hp = NULL;
7204
7205       if (symp != NULL)
7206         *symp = sym;
7207
7208       if (symsecp != NULL)
7209         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7210
7211       if (tls_maskp != NULL)
7212         {
7213           struct got_entry **lgot_ents;
7214           unsigned char *tls_mask;
7215
7216           tls_mask = NULL;
7217           lgot_ents = elf_local_got_ents (ibfd);
7218           if (lgot_ents != NULL)
7219             {
7220               struct plt_entry **local_plt = (struct plt_entry **)
7221                 (lgot_ents + symtab_hdr->sh_info);
7222               unsigned char *lgot_masks = (unsigned char *)
7223                 (local_plt + symtab_hdr->sh_info);
7224               tls_mask = &lgot_masks[r_symndx];
7225             }
7226           *tls_maskp = tls_mask;
7227         }
7228     }
7229   return TRUE;
7230 }
7231
7232 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7233    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7234    type suitable for optimization, and 1 otherwise.  */
7235
7236 static int
7237 get_tls_mask (unsigned char **tls_maskp,
7238               unsigned long *toc_symndx,
7239               bfd_vma *toc_addend,
7240               Elf_Internal_Sym **locsymsp,
7241               const Elf_Internal_Rela *rel,
7242               bfd *ibfd)
7243 {
7244   unsigned long r_symndx;
7245   int next_r;
7246   struct elf_link_hash_entry *h;
7247   Elf_Internal_Sym *sym;
7248   asection *sec;
7249   bfd_vma off;
7250
7251   r_symndx = ELF64_R_SYM (rel->r_info);
7252   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7253     return 0;
7254
7255   if ((*tls_maskp != NULL && **tls_maskp != 0)
7256       || sec == NULL
7257       || ppc64_elf_section_data (sec) == NULL
7258       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7259     return 1;
7260
7261   /* Look inside a TOC section too.  */
7262   if (h != NULL)
7263     {
7264       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7265       off = h->root.u.def.value;
7266     }
7267   else
7268     off = sym->st_value;
7269   off += rel->r_addend;
7270   BFD_ASSERT (off % 8 == 0);
7271   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7272   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7273   if (toc_symndx != NULL)
7274     *toc_symndx = r_symndx;
7275   if (toc_addend != NULL)
7276     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7277   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7278     return 0;
7279   if ((h == NULL || is_static_defined (h))
7280       && (next_r == -1 || next_r == -2))
7281     return 1 - next_r;
7282   return 1;
7283 }
7284
7285 /* Find (or create) an entry in the tocsave hash table.  */
7286
7287 static struct tocsave_entry *
7288 tocsave_find (struct ppc_link_hash_table *htab,
7289               enum insert_option insert,
7290               Elf_Internal_Sym **local_syms,
7291               const Elf_Internal_Rela *irela,
7292               bfd *ibfd)
7293 {
7294   unsigned long r_indx;
7295   struct elf_link_hash_entry *h;
7296   Elf_Internal_Sym *sym;
7297   struct tocsave_entry ent, *p;
7298   hashval_t hash;
7299   struct tocsave_entry **slot;
7300
7301   r_indx = ELF64_R_SYM (irela->r_info);
7302   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7303     return NULL;
7304   if (ent.sec == NULL || ent.sec->output_section == NULL)
7305     {
7306       (*_bfd_error_handler)
7307         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7308       return NULL;
7309     }
7310
7311   if (h != NULL)
7312     ent.offset = h->root.u.def.value;
7313   else
7314     ent.offset = sym->st_value;
7315   ent.offset += irela->r_addend;
7316
7317   hash = tocsave_htab_hash (&ent);
7318   slot = ((struct tocsave_entry **)
7319           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7320   if (slot == NULL)
7321     return NULL;
7322
7323   if (*slot == NULL)
7324     {
7325       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7326       if (p == NULL)
7327         return NULL;
7328       *p = ent;
7329       *slot = p;
7330     }
7331   return *slot;
7332 }
7333
7334 /* Adjust all global syms defined in opd sections.  In gcc generated
7335    code for the old ABI, these will already have been done.  */
7336
7337 static bfd_boolean
7338 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7339 {
7340   struct ppc_link_hash_entry *eh;
7341   asection *sym_sec;
7342   struct _opd_sec_data *opd;
7343
7344   if (h->root.type == bfd_link_hash_indirect)
7345     return TRUE;
7346
7347   if (h->root.type != bfd_link_hash_defined
7348       && h->root.type != bfd_link_hash_defweak)
7349     return TRUE;
7350
7351   eh = (struct ppc_link_hash_entry *) h;
7352   if (eh->adjust_done)
7353     return TRUE;
7354
7355   sym_sec = eh->elf.root.u.def.section;
7356   opd = get_opd_info (sym_sec);
7357   if (opd != NULL && opd->adjust != NULL)
7358     {
7359       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7360       if (adjust == -1)
7361         {
7362           /* This entry has been deleted.  */
7363           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7364           if (dsec == NULL)
7365             {
7366               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7367                 if (discarded_section (dsec))
7368                   {
7369                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7370                     break;
7371                   }
7372             }
7373           eh->elf.root.u.def.value = 0;
7374           eh->elf.root.u.def.section = dsec;
7375         }
7376       else
7377         eh->elf.root.u.def.value += adjust;
7378       eh->adjust_done = 1;
7379     }
7380   return TRUE;
7381 }
7382
7383 /* Handles decrementing dynamic reloc counts for the reloc specified by
7384    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7385    have already been determined.  */
7386
7387 static bfd_boolean
7388 dec_dynrel_count (bfd_vma r_info,
7389                   asection *sec,
7390                   struct bfd_link_info *info,
7391                   Elf_Internal_Sym **local_syms,
7392                   struct elf_link_hash_entry *h,
7393                   Elf_Internal_Sym *sym)
7394 {
7395   enum elf_ppc64_reloc_type r_type;
7396   asection *sym_sec = NULL;
7397
7398   /* Can this reloc be dynamic?  This switch, and later tests here
7399      should be kept in sync with the code in check_relocs.  */
7400   r_type = ELF64_R_TYPE (r_info);
7401   switch (r_type)
7402     {
7403     default:
7404       return TRUE;
7405
7406     case R_PPC64_TPREL16:
7407     case R_PPC64_TPREL16_LO:
7408     case R_PPC64_TPREL16_HI:
7409     case R_PPC64_TPREL16_HA:
7410     case R_PPC64_TPREL16_DS:
7411     case R_PPC64_TPREL16_LO_DS:
7412     case R_PPC64_TPREL16_HIGH:
7413     case R_PPC64_TPREL16_HIGHA:
7414     case R_PPC64_TPREL16_HIGHER:
7415     case R_PPC64_TPREL16_HIGHERA:
7416     case R_PPC64_TPREL16_HIGHEST:
7417     case R_PPC64_TPREL16_HIGHESTA:
7418       if (!info->shared)
7419         return TRUE;
7420
7421     case R_PPC64_TPREL64:
7422     case R_PPC64_DTPMOD64:
7423     case R_PPC64_DTPREL64:
7424     case R_PPC64_ADDR64:
7425     case R_PPC64_REL30:
7426     case R_PPC64_REL32:
7427     case R_PPC64_REL64:
7428     case R_PPC64_ADDR14:
7429     case R_PPC64_ADDR14_BRNTAKEN:
7430     case R_PPC64_ADDR14_BRTAKEN:
7431     case R_PPC64_ADDR16:
7432     case R_PPC64_ADDR16_DS:
7433     case R_PPC64_ADDR16_HA:
7434     case R_PPC64_ADDR16_HI:
7435     case R_PPC64_ADDR16_HIGH:
7436     case R_PPC64_ADDR16_HIGHA:
7437     case R_PPC64_ADDR16_HIGHER:
7438     case R_PPC64_ADDR16_HIGHERA:
7439     case R_PPC64_ADDR16_HIGHEST:
7440     case R_PPC64_ADDR16_HIGHESTA:
7441     case R_PPC64_ADDR16_LO:
7442     case R_PPC64_ADDR16_LO_DS:
7443     case R_PPC64_ADDR24:
7444     case R_PPC64_ADDR32:
7445     case R_PPC64_UADDR16:
7446     case R_PPC64_UADDR32:
7447     case R_PPC64_UADDR64:
7448     case R_PPC64_TOC:
7449       break;
7450     }
7451
7452   if (local_syms != NULL)
7453     {
7454       unsigned long r_symndx;
7455       bfd *ibfd = sec->owner;
7456
7457       r_symndx = ELF64_R_SYM (r_info);
7458       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7459         return FALSE;
7460     }
7461
7462   if ((info->shared
7463        && (must_be_dyn_reloc (info, r_type)
7464            || (h != NULL
7465                && (!SYMBOLIC_BIND (info, h)
7466                    || h->root.type == bfd_link_hash_defweak
7467                    || !h->def_regular))))
7468       || (ELIMINATE_COPY_RELOCS
7469           && !info->shared
7470           && h != NULL
7471           && (h->root.type == bfd_link_hash_defweak
7472               || !h->def_regular)))
7473     ;
7474   else
7475     return TRUE;
7476
7477   if (h != NULL)
7478     {
7479       struct elf_dyn_relocs *p;
7480       struct elf_dyn_relocs **pp;
7481       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7482
7483       /* elf_gc_sweep may have already removed all dyn relocs associated
7484          with local syms for a given section.  Also, symbol flags are
7485          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7486          report a dynreloc miscount.  */
7487       if (*pp == NULL && info->gc_sections)
7488         return TRUE;
7489
7490       while ((p = *pp) != NULL)
7491         {
7492           if (p->sec == sec)
7493             {
7494               if (!must_be_dyn_reloc (info, r_type))
7495                 p->pc_count -= 1;
7496               p->count -= 1;
7497               if (p->count == 0)
7498                 *pp = p->next;
7499               return TRUE;
7500             }
7501           pp = &p->next;
7502         }
7503     }
7504   else
7505     {
7506       struct ppc_dyn_relocs *p;
7507       struct ppc_dyn_relocs **pp;
7508       void *vpp;
7509       bfd_boolean is_ifunc;
7510
7511       if (local_syms == NULL)
7512         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7513       if (sym_sec == NULL)
7514         sym_sec = sec;
7515
7516       vpp = &elf_section_data (sym_sec)->local_dynrel;
7517       pp = (struct ppc_dyn_relocs **) vpp;
7518
7519       if (*pp == NULL && info->gc_sections)
7520         return TRUE;
7521
7522       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7523       while ((p = *pp) != NULL)
7524         {
7525           if (p->sec == sec && p->ifunc == is_ifunc)
7526             {
7527               p->count -= 1;
7528               if (p->count == 0)
7529                 *pp = p->next;
7530               return TRUE;
7531             }
7532           pp = &p->next;
7533         }
7534     }
7535
7536   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7537                           sec->owner, sec);
7538   bfd_set_error (bfd_error_bad_value);
7539   return FALSE;
7540 }
7541
7542 /* Remove unused Official Procedure Descriptor entries.  Currently we
7543    only remove those associated with functions in discarded link-once
7544    sections, or weakly defined functions that have been overridden.  It
7545    would be possible to remove many more entries for statically linked
7546    applications.  */
7547
7548 bfd_boolean
7549 ppc64_elf_edit_opd (struct bfd_link_info *info)
7550 {
7551   bfd *ibfd;
7552   bfd_boolean some_edited = FALSE;
7553   asection *need_pad = NULL;
7554   struct ppc_link_hash_table *htab;
7555
7556   htab = ppc_hash_table (info);
7557   if (htab == NULL)
7558     return FALSE;
7559
7560   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7561     {
7562       asection *sec;
7563       Elf_Internal_Rela *relstart, *rel, *relend;
7564       Elf_Internal_Shdr *symtab_hdr;
7565       Elf_Internal_Sym *local_syms;
7566       bfd_vma offset;
7567       struct _opd_sec_data *opd;
7568       bfd_boolean need_edit, add_aux_fields;
7569       bfd_size_type cnt_16b = 0;
7570
7571       if (!is_ppc64_elf (ibfd))
7572         continue;
7573
7574       sec = bfd_get_section_by_name (ibfd, ".opd");
7575       if (sec == NULL || sec->size == 0)
7576         continue;
7577
7578       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7579         continue;
7580
7581       if (sec->output_section == bfd_abs_section_ptr)
7582         continue;
7583
7584       /* Look through the section relocs.  */
7585       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7586         continue;
7587
7588       local_syms = NULL;
7589       symtab_hdr = &elf_symtab_hdr (ibfd);
7590
7591       /* Read the relocations.  */
7592       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7593                                             info->keep_memory);
7594       if (relstart == NULL)
7595         return FALSE;
7596
7597       /* First run through the relocs to check they are sane, and to
7598          determine whether we need to edit this opd section.  */
7599       need_edit = FALSE;
7600       need_pad = sec;
7601       offset = 0;
7602       relend = relstart + sec->reloc_count;
7603       for (rel = relstart; rel < relend; )
7604         {
7605           enum elf_ppc64_reloc_type r_type;
7606           unsigned long r_symndx;
7607           asection *sym_sec;
7608           struct elf_link_hash_entry *h;
7609           Elf_Internal_Sym *sym;
7610
7611           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7612              only interested in the reloc pointing to a function entry
7613              point.  */
7614           if (rel->r_offset != offset
7615               || rel + 1 >= relend
7616               || (rel + 1)->r_offset != offset + 8)
7617             {
7618               /* If someone messes with .opd alignment then after a
7619                  "ld -r" we might have padding in the middle of .opd.
7620                  Also, there's nothing to prevent someone putting
7621                  something silly in .opd with the assembler.  No .opd
7622                  optimization for them!  */
7623             broken_opd:
7624               (*_bfd_error_handler)
7625                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7626               need_edit = FALSE;
7627               break;
7628             }
7629
7630           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7631               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7632             {
7633               (*_bfd_error_handler)
7634                 (_("%B: unexpected reloc type %u in .opd section"),
7635                  ibfd, r_type);
7636               need_edit = FALSE;
7637               break;
7638             }
7639
7640           r_symndx = ELF64_R_SYM (rel->r_info);
7641           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7642                           r_symndx, ibfd))
7643             goto error_ret;
7644
7645           if (sym_sec == NULL || sym_sec->owner == NULL)
7646             {
7647               const char *sym_name;
7648               if (h != NULL)
7649                 sym_name = h->root.root.string;
7650               else
7651                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7652                                              sym_sec);
7653
7654               (*_bfd_error_handler)
7655                 (_("%B: undefined sym `%s' in .opd section"),
7656                  ibfd, sym_name);
7657               need_edit = FALSE;
7658               break;
7659             }
7660
7661           /* opd entries are always for functions defined in the
7662              current input bfd.  If the symbol isn't defined in the
7663              input bfd, then we won't be using the function in this
7664              bfd;  It must be defined in a linkonce section in another
7665              bfd, or is weak.  It's also possible that we are
7666              discarding the function due to a linker script /DISCARD/,
7667              which we test for via the output_section.  */
7668           if (sym_sec->owner != ibfd
7669               || sym_sec->output_section == bfd_abs_section_ptr)
7670             need_edit = TRUE;
7671
7672           rel += 2;
7673           if (rel == relend
7674               || (rel + 1 == relend && rel->r_offset == offset + 16))
7675             {
7676               if (sec->size == offset + 24)
7677                 {
7678                   need_pad = NULL;
7679                   break;
7680                 }
7681               if (rel == relend && sec->size == offset + 16)
7682                 {
7683                   cnt_16b++;
7684                   break;
7685                 }
7686               goto broken_opd;
7687             }
7688
7689           if (rel->r_offset == offset + 24)
7690             offset += 24;
7691           else if (rel->r_offset != offset + 16)
7692             goto broken_opd;
7693           else if (rel + 1 < relend
7694                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7695                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7696             {
7697               offset += 16;
7698               cnt_16b++;
7699             }
7700           else if (rel + 2 < relend
7701                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7702                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7703             {
7704               offset += 24;
7705               rel += 1;
7706             }
7707           else
7708             goto broken_opd;
7709         }
7710
7711       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7712
7713       if (need_edit || add_aux_fields)
7714         {
7715           Elf_Internal_Rela *write_rel;
7716           Elf_Internal_Shdr *rel_hdr;
7717           bfd_byte *rptr, *wptr;
7718           bfd_byte *new_contents;
7719           bfd_boolean skip;
7720           long opd_ent_size;
7721           bfd_size_type amt;
7722
7723           new_contents = NULL;
7724           amt = sec->size * sizeof (long) / 8;
7725           opd = &ppc64_elf_section_data (sec)->u.opd;
7726           opd->adjust = bfd_zalloc (sec->owner, amt);
7727           if (opd->adjust == NULL)
7728             return FALSE;
7729           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7730
7731           /* This seems a waste of time as input .opd sections are all
7732              zeros as generated by gcc, but I suppose there's no reason
7733              this will always be so.  We might start putting something in
7734              the third word of .opd entries.  */
7735           if ((sec->flags & SEC_IN_MEMORY) == 0)
7736             {
7737               bfd_byte *loc;
7738               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7739                 {
7740                   if (loc != NULL)
7741                     free (loc);
7742                 error_ret:
7743                   if (local_syms != NULL
7744                       && symtab_hdr->contents != (unsigned char *) local_syms)
7745                     free (local_syms);
7746                   if (elf_section_data (sec)->relocs != relstart)
7747                     free (relstart);
7748                   return FALSE;
7749                 }
7750               sec->contents = loc;
7751               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7752             }
7753
7754           elf_section_data (sec)->relocs = relstart;
7755
7756           new_contents = sec->contents;
7757           if (add_aux_fields)
7758             {
7759               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7760               if (new_contents == NULL)
7761                 return FALSE;
7762               need_pad = FALSE;
7763             }
7764           wptr = new_contents;
7765           rptr = sec->contents;
7766
7767           write_rel = relstart;
7768           skip = FALSE;
7769           offset = 0;
7770           opd_ent_size = 0;
7771           for (rel = relstart; rel < relend; rel++)
7772             {
7773               unsigned long r_symndx;
7774               asection *sym_sec;
7775               struct elf_link_hash_entry *h;
7776               Elf_Internal_Sym *sym;
7777
7778               r_symndx = ELF64_R_SYM (rel->r_info);
7779               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7780                               r_symndx, ibfd))
7781                 goto error_ret;
7782
7783               if (rel->r_offset == offset)
7784                 {
7785                   struct ppc_link_hash_entry *fdh = NULL;
7786
7787                   /* See if the .opd entry is full 24 byte or
7788                      16 byte (with fd_aux entry overlapped with next
7789                      fd_func).  */
7790                   opd_ent_size = 24;
7791                   if ((rel + 2 == relend && sec->size == offset + 16)
7792                       || (rel + 3 < relend
7793                           && rel[2].r_offset == offset + 16
7794                           && rel[3].r_offset == offset + 24
7795                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7796                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7797                     opd_ent_size = 16;
7798
7799                   if (h != NULL
7800                       && h->root.root.string[0] == '.')
7801                     {
7802                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7803                       if (fdh != NULL
7804                           && fdh->elf.root.type != bfd_link_hash_defined
7805                           && fdh->elf.root.type != bfd_link_hash_defweak)
7806                         fdh = NULL;
7807                     }
7808
7809                   skip = (sym_sec->owner != ibfd
7810                           || sym_sec->output_section == bfd_abs_section_ptr);
7811                   if (skip)
7812                     {
7813                       if (fdh != NULL && sym_sec->owner == ibfd)
7814                         {
7815                           /* Arrange for the function descriptor sym
7816                              to be dropped.  */
7817                           fdh->elf.root.u.def.value = 0;
7818                           fdh->elf.root.u.def.section = sym_sec;
7819                         }
7820                       opd->adjust[rel->r_offset / 8] = -1;
7821                     }
7822                   else
7823                     {
7824                       /* We'll be keeping this opd entry.  */
7825
7826                       if (fdh != NULL)
7827                         {
7828                           /* Redefine the function descriptor symbol to
7829                              this location in the opd section.  It is
7830                              necessary to update the value here rather
7831                              than using an array of adjustments as we do
7832                              for local symbols, because various places
7833                              in the generic ELF code use the value
7834                              stored in u.def.value.  */
7835                           fdh->elf.root.u.def.value = wptr - new_contents;
7836                           fdh->adjust_done = 1;
7837                         }
7838
7839                       /* Local syms are a bit tricky.  We could
7840                          tweak them as they can be cached, but
7841                          we'd need to look through the local syms
7842                          for the function descriptor sym which we
7843                          don't have at the moment.  So keep an
7844                          array of adjustments.  */
7845                       opd->adjust[rel->r_offset / 8]
7846                         = (wptr - new_contents) - (rptr - sec->contents);
7847
7848                       if (wptr != rptr)
7849                         memcpy (wptr, rptr, opd_ent_size);
7850                       wptr += opd_ent_size;
7851                       if (add_aux_fields && opd_ent_size == 16)
7852                         {
7853                           memset (wptr, '\0', 8);
7854                           wptr += 8;
7855                         }
7856                     }
7857                   rptr += opd_ent_size;
7858                   offset += opd_ent_size;
7859                 }
7860
7861               if (skip)
7862                 {
7863                   if (!NO_OPD_RELOCS
7864                       && !info->relocatable
7865                       && !dec_dynrel_count (rel->r_info, sec, info,
7866                                             NULL, h, sym))
7867                     goto error_ret;
7868                 }
7869               else
7870                 {
7871                   /* We need to adjust any reloc offsets to point to the
7872                      new opd entries.  While we're at it, we may as well
7873                      remove redundant relocs.  */
7874                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7875                   if (write_rel != rel)
7876                     memcpy (write_rel, rel, sizeof (*rel));
7877                   ++write_rel;
7878                 }
7879             }
7880
7881           sec->size = wptr - new_contents;
7882           sec->reloc_count = write_rel - relstart;
7883           if (add_aux_fields)
7884             {
7885               free (sec->contents);
7886               sec->contents = new_contents;
7887             }
7888
7889           /* Fudge the header size too, as this is used later in
7890              elf_bfd_final_link if we are emitting relocs.  */
7891           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7892           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7893           some_edited = TRUE;
7894         }
7895       else if (elf_section_data (sec)->relocs != relstart)
7896         free (relstart);
7897
7898       if (local_syms != NULL
7899           && symtab_hdr->contents != (unsigned char *) local_syms)
7900         {
7901           if (!info->keep_memory)
7902             free (local_syms);
7903           else
7904             symtab_hdr->contents = (unsigned char *) local_syms;
7905         }
7906     }
7907
7908   if (some_edited)
7909     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7910
7911   /* If we are doing a final link and the last .opd entry is just 16 byte
7912      long, add a 8 byte padding after it.  */
7913   if (need_pad != NULL && !info->relocatable)
7914     {
7915       bfd_byte *p;
7916
7917       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7918         {
7919           BFD_ASSERT (need_pad->size > 0);
7920
7921           p = bfd_malloc (need_pad->size + 8);
7922           if (p == NULL)
7923             return FALSE;
7924
7925           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7926                                           p, 0, need_pad->size))
7927             return FALSE;
7928
7929           need_pad->contents = p;
7930           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7931         }
7932       else
7933         {
7934           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7935           if (p == NULL)
7936             return FALSE;
7937
7938           need_pad->contents = p;
7939         }
7940
7941       memset (need_pad->contents + need_pad->size, 0, 8);
7942       need_pad->size += 8;
7943     }
7944
7945   return TRUE;
7946 }
7947
7948 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7949
7950 asection *
7951 ppc64_elf_tls_setup (struct bfd_link_info *info)
7952 {
7953   struct ppc_link_hash_table *htab;
7954
7955   htab = ppc_hash_table (info);
7956   if (htab == NULL)
7957     return NULL;
7958
7959   if (abiversion (info->output_bfd) == 1)
7960     htab->opd_abi = 1;
7961
7962   if (htab->params->no_multi_toc)
7963     htab->do_multi_toc = 0;
7964   else if (!htab->do_multi_toc)
7965     htab->params->no_multi_toc = 1;
7966
7967   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7968                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7969                                               FALSE, FALSE, TRUE));
7970   /* Move dynamic linking info to the function descriptor sym.  */
7971   if (htab->tls_get_addr != NULL)
7972     func_desc_adjust (&htab->tls_get_addr->elf, info);
7973   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7974                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7975                                                  FALSE, FALSE, TRUE));
7976   if (!htab->params->no_tls_get_addr_opt)
7977     {
7978       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7979
7980       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7981                                   FALSE, FALSE, TRUE);
7982       if (opt != NULL)
7983         func_desc_adjust (opt, info);
7984       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7985                                      FALSE, FALSE, TRUE);
7986       if (opt_fd != NULL
7987           && (opt_fd->root.type == bfd_link_hash_defined
7988               || opt_fd->root.type == bfd_link_hash_defweak))
7989         {
7990           /* If glibc supports an optimized __tls_get_addr call stub,
7991              signalled by the presence of __tls_get_addr_opt, and we'll
7992              be calling __tls_get_addr via a plt call stub, then
7993              make __tls_get_addr point to __tls_get_addr_opt.  */
7994           tga_fd = &htab->tls_get_addr_fd->elf;
7995           if (htab->elf.dynamic_sections_created
7996               && tga_fd != NULL
7997               && (tga_fd->type == STT_FUNC
7998                   || tga_fd->needs_plt)
7999               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8000                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8001                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8002             {
8003               struct plt_entry *ent;
8004
8005               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8006                 if (ent->plt.refcount > 0)
8007                   break;
8008               if (ent != NULL)
8009                 {
8010                   tga_fd->root.type = bfd_link_hash_indirect;
8011                   tga_fd->root.u.i.link = &opt_fd->root;
8012                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8013                   if (opt_fd->dynindx != -1)
8014                     {
8015                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8016                       opt_fd->dynindx = -1;
8017                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8018                                               opt_fd->dynstr_index);
8019                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8020                         return NULL;
8021                     }
8022                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8023                   tga = &htab->tls_get_addr->elf;
8024                   if (opt != NULL && tga != NULL)
8025                     {
8026                       tga->root.type = bfd_link_hash_indirect;
8027                       tga->root.u.i.link = &opt->root;
8028                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8029                       _bfd_elf_link_hash_hide_symbol (info, opt,
8030                                                       tga->forced_local);
8031                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8032                     }
8033                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8034                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8035                   if (htab->tls_get_addr != NULL)
8036                     {
8037                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8038                       htab->tls_get_addr->is_func = 1;
8039                     }
8040                 }
8041             }
8042         }
8043       else
8044         htab->params->no_tls_get_addr_opt = TRUE;
8045     }
8046   return _bfd_elf_tls_setup (info->output_bfd, info);
8047 }
8048
8049 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8050    HASH1 or HASH2.  */
8051
8052 static bfd_boolean
8053 branch_reloc_hash_match (const bfd *ibfd,
8054                          const Elf_Internal_Rela *rel,
8055                          const struct ppc_link_hash_entry *hash1,
8056                          const struct ppc_link_hash_entry *hash2)
8057 {
8058   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8059   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8060   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8061
8062   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8063     {
8064       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8065       struct elf_link_hash_entry *h;
8066
8067       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8068       h = elf_follow_link (h);
8069       if (h == &hash1->elf || h == &hash2->elf)
8070         return TRUE;
8071     }
8072   return FALSE;
8073 }
8074
8075 /* Run through all the TLS relocs looking for optimization
8076    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8077    a preliminary section layout so that we know the TLS segment
8078    offsets.  We can't optimize earlier because some optimizations need
8079    to know the tp offset, and we need to optimize before allocating
8080    dynamic relocations.  */
8081
8082 bfd_boolean
8083 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8084 {
8085   bfd *ibfd;
8086   asection *sec;
8087   struct ppc_link_hash_table *htab;
8088   unsigned char *toc_ref;
8089   int pass;
8090
8091   if (info->relocatable || !info->executable)
8092     return TRUE;
8093
8094   htab = ppc_hash_table (info);
8095   if (htab == NULL)
8096     return FALSE;
8097
8098   /* Make two passes over the relocs.  On the first pass, mark toc
8099      entries involved with tls relocs, and check that tls relocs
8100      involved in setting up a tls_get_addr call are indeed followed by
8101      such a call.  If they are not, we can't do any tls optimization.
8102      On the second pass twiddle tls_mask flags to notify
8103      relocate_section that optimization can be done, and adjust got
8104      and plt refcounts.  */
8105   toc_ref = NULL;
8106   for (pass = 0; pass < 2; ++pass)
8107     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8108       {
8109         Elf_Internal_Sym *locsyms = NULL;
8110         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8111
8112         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8113           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8114             {
8115               Elf_Internal_Rela *relstart, *rel, *relend;
8116               bfd_boolean found_tls_get_addr_arg = 0;
8117
8118               /* Read the relocations.  */
8119               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8120                                                     info->keep_memory);
8121               if (relstart == NULL)
8122                 {
8123                   free (toc_ref);
8124                   return FALSE;
8125                 }
8126
8127               relend = relstart + sec->reloc_count;
8128               for (rel = relstart; rel < relend; rel++)
8129                 {
8130                   enum elf_ppc64_reloc_type r_type;
8131                   unsigned long r_symndx;
8132                   struct elf_link_hash_entry *h;
8133                   Elf_Internal_Sym *sym;
8134                   asection *sym_sec;
8135                   unsigned char *tls_mask;
8136                   unsigned char tls_set, tls_clear, tls_type = 0;
8137                   bfd_vma value;
8138                   bfd_boolean ok_tprel, is_local;
8139                   long toc_ref_index = 0;
8140                   int expecting_tls_get_addr = 0;
8141                   bfd_boolean ret = FALSE;
8142
8143                   r_symndx = ELF64_R_SYM (rel->r_info);
8144                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8145                                   r_symndx, ibfd))
8146                     {
8147                     err_free_rel:
8148                       if (elf_section_data (sec)->relocs != relstart)
8149                         free (relstart);
8150                       if (toc_ref != NULL)
8151                         free (toc_ref);
8152                       if (locsyms != NULL
8153                           && (elf_symtab_hdr (ibfd).contents
8154                               != (unsigned char *) locsyms))
8155                         free (locsyms);
8156                       return ret;
8157                     }
8158
8159                   if (h != NULL)
8160                     {
8161                       if (h->root.type == bfd_link_hash_defined
8162                           || h->root.type == bfd_link_hash_defweak)
8163                         value = h->root.u.def.value;
8164                       else if (h->root.type == bfd_link_hash_undefweak)
8165                         value = 0;
8166                       else
8167                         {
8168                           found_tls_get_addr_arg = 0;
8169                           continue;
8170                         }
8171                     }
8172                   else
8173                     /* Symbols referenced by TLS relocs must be of type
8174                        STT_TLS.  So no need for .opd local sym adjust.  */
8175                     value = sym->st_value;
8176
8177                   ok_tprel = FALSE;
8178                   is_local = FALSE;
8179                   if (h == NULL
8180                       || !h->def_dynamic)
8181                     {
8182                       is_local = TRUE;
8183                       if (h != NULL
8184                           && h->root.type == bfd_link_hash_undefweak)
8185                         ok_tprel = TRUE;
8186                       else
8187                         {
8188                           value += sym_sec->output_offset;
8189                           value += sym_sec->output_section->vma;
8190                           value -= htab->elf.tls_sec->vma;
8191                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8192                                       < (bfd_vma) 1 << 32);
8193                         }
8194                     }
8195
8196                   r_type = ELF64_R_TYPE (rel->r_info);
8197                   /* If this section has old-style __tls_get_addr calls
8198                      without marker relocs, then check that each
8199                      __tls_get_addr call reloc is preceded by a reloc
8200                      that conceivably belongs to the __tls_get_addr arg
8201                      setup insn.  If we don't find matching arg setup
8202                      relocs, don't do any tls optimization.  */
8203                   if (pass == 0
8204                       && sec->has_tls_get_addr_call
8205                       && h != NULL
8206                       && (h == &htab->tls_get_addr->elf
8207                           || h == &htab->tls_get_addr_fd->elf)
8208                       && !found_tls_get_addr_arg
8209                       && is_branch_reloc (r_type))
8210                     {
8211                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8212                                                 "TLS optimization disabled\n"),
8213                                               ibfd, sec, rel->r_offset);
8214                       ret = TRUE;
8215                       goto err_free_rel;
8216                     }
8217
8218                   found_tls_get_addr_arg = 0;
8219                   switch (r_type)
8220                     {
8221                     case R_PPC64_GOT_TLSLD16:
8222                     case R_PPC64_GOT_TLSLD16_LO:
8223                       expecting_tls_get_addr = 1;
8224                       found_tls_get_addr_arg = 1;
8225                       /* Fall thru */
8226
8227                     case R_PPC64_GOT_TLSLD16_HI:
8228                     case R_PPC64_GOT_TLSLD16_HA:
8229                       /* These relocs should never be against a symbol
8230                          defined in a shared lib.  Leave them alone if
8231                          that turns out to be the case.  */
8232                       if (!is_local)
8233                         continue;
8234
8235                       /* LD -> LE */
8236                       tls_set = 0;
8237                       tls_clear = TLS_LD;
8238                       tls_type = TLS_TLS | TLS_LD;
8239                       break;
8240
8241                     case R_PPC64_GOT_TLSGD16:
8242                     case R_PPC64_GOT_TLSGD16_LO:
8243                       expecting_tls_get_addr = 1;
8244                       found_tls_get_addr_arg = 1;
8245                       /* Fall thru */
8246
8247                     case R_PPC64_GOT_TLSGD16_HI:
8248                     case R_PPC64_GOT_TLSGD16_HA:
8249                       if (ok_tprel)
8250                         /* GD -> LE */
8251                         tls_set = 0;
8252                       else
8253                         /* GD -> IE */
8254                         tls_set = TLS_TLS | TLS_TPRELGD;
8255                       tls_clear = TLS_GD;
8256                       tls_type = TLS_TLS | TLS_GD;
8257                       break;
8258
8259                     case R_PPC64_GOT_TPREL16_DS:
8260                     case R_PPC64_GOT_TPREL16_LO_DS:
8261                     case R_PPC64_GOT_TPREL16_HI:
8262                     case R_PPC64_GOT_TPREL16_HA:
8263                       if (ok_tprel)
8264                         {
8265                           /* IE -> LE */
8266                           tls_set = 0;
8267                           tls_clear = TLS_TPREL;
8268                           tls_type = TLS_TLS | TLS_TPREL;
8269                           break;
8270                         }
8271                       continue;
8272
8273                     case R_PPC64_TLSGD:
8274                     case R_PPC64_TLSLD:
8275                       found_tls_get_addr_arg = 1;
8276                       /* Fall thru */
8277
8278                     case R_PPC64_TLS:
8279                     case R_PPC64_TOC16:
8280                     case R_PPC64_TOC16_LO:
8281                       if (sym_sec == NULL || sym_sec != toc)
8282                         continue;
8283
8284                       /* Mark this toc entry as referenced by a TLS
8285                          code sequence.  We can do that now in the
8286                          case of R_PPC64_TLS, and after checking for
8287                          tls_get_addr for the TOC16 relocs.  */
8288                       if (toc_ref == NULL)
8289                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8290                       if (toc_ref == NULL)
8291                         goto err_free_rel;
8292
8293                       if (h != NULL)
8294                         value = h->root.u.def.value;
8295                       else
8296                         value = sym->st_value;
8297                       value += rel->r_addend;
8298                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8299                       toc_ref_index = (value + toc->output_offset) / 8;
8300                       if (r_type == R_PPC64_TLS
8301                           || r_type == R_PPC64_TLSGD
8302                           || r_type == R_PPC64_TLSLD)
8303                         {
8304                           toc_ref[toc_ref_index] = 1;
8305                           continue;
8306                         }
8307
8308                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8309                         continue;
8310
8311                       tls_set = 0;
8312                       tls_clear = 0;
8313                       expecting_tls_get_addr = 2;
8314                       break;
8315
8316                     case R_PPC64_TPREL64:
8317                       if (pass == 0
8318                           || sec != toc
8319                           || toc_ref == NULL
8320                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8321                         continue;
8322                       if (ok_tprel)
8323                         {
8324                           /* IE -> LE */
8325                           tls_set = TLS_EXPLICIT;
8326                           tls_clear = TLS_TPREL;
8327                           break;
8328                         }
8329                       continue;
8330
8331                     case R_PPC64_DTPMOD64:
8332                       if (pass == 0
8333                           || sec != toc
8334                           || toc_ref == NULL
8335                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8336                         continue;
8337                       if (rel + 1 < relend
8338                           && (rel[1].r_info
8339                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8340                           && rel[1].r_offset == rel->r_offset + 8)
8341                         {
8342                           if (ok_tprel)
8343                             /* GD -> LE */
8344                             tls_set = TLS_EXPLICIT | TLS_GD;
8345                           else
8346                             /* GD -> IE */
8347                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8348                           tls_clear = TLS_GD;
8349                         }
8350                       else
8351                         {
8352                           if (!is_local)
8353                             continue;
8354
8355                           /* LD -> LE */
8356                           tls_set = TLS_EXPLICIT;
8357                           tls_clear = TLS_LD;
8358                         }
8359                       break;
8360
8361                     default:
8362                       continue;
8363                     }
8364
8365                   if (pass == 0)
8366                     {
8367                       if (!expecting_tls_get_addr
8368                           || !sec->has_tls_get_addr_call)
8369                         continue;
8370
8371                       if (rel + 1 < relend
8372                           && branch_reloc_hash_match (ibfd, rel + 1,
8373                                                       htab->tls_get_addr,
8374                                                       htab->tls_get_addr_fd))
8375                         {
8376                           if (expecting_tls_get_addr == 2)
8377                             {
8378                               /* Check for toc tls entries.  */
8379                               unsigned char *toc_tls;
8380                               int retval;
8381
8382                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8383                                                      &locsyms,
8384                                                      rel, ibfd);
8385                               if (retval == 0)
8386                                 goto err_free_rel;
8387                               if (toc_tls != NULL)
8388                                 {
8389                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8390                                     found_tls_get_addr_arg = 1;
8391                                   if (retval > 1)
8392                                     toc_ref[toc_ref_index] = 1;
8393                                 }
8394                             }
8395                           continue;
8396                         }
8397
8398                       if (expecting_tls_get_addr != 1)
8399                         continue;
8400
8401                       /* Uh oh, we didn't find the expected call.  We
8402                          could just mark this symbol to exclude it
8403                          from tls optimization but it's safer to skip
8404                          the entire optimization.  */
8405                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8406                                                 "TLS optimization disabled\n"),
8407                                               ibfd, sec, rel->r_offset);
8408                       ret = TRUE;
8409                       goto err_free_rel;
8410                     }
8411
8412                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8413                     {
8414                       struct plt_entry *ent;
8415                       for (ent = htab->tls_get_addr->elf.plt.plist;
8416                            ent != NULL;
8417                            ent = ent->next)
8418                         if (ent->addend == 0)
8419                           {
8420                             if (ent->plt.refcount > 0)
8421                               {
8422                                 ent->plt.refcount -= 1;
8423                                 expecting_tls_get_addr = 0;
8424                               }
8425                             break;
8426                           }
8427                     }
8428
8429                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8430                     {
8431                       struct plt_entry *ent;
8432                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8433                            ent != NULL;
8434                            ent = ent->next)
8435                         if (ent->addend == 0)
8436                           {
8437                             if (ent->plt.refcount > 0)
8438                               ent->plt.refcount -= 1;
8439                             break;
8440                           }
8441                     }
8442
8443                   if (tls_clear == 0)
8444                     continue;
8445
8446                   if ((tls_set & TLS_EXPLICIT) == 0)
8447                     {
8448                       struct got_entry *ent;
8449
8450                       /* Adjust got entry for this reloc.  */
8451                       if (h != NULL)
8452                         ent = h->got.glist;
8453                       else
8454                         ent = elf_local_got_ents (ibfd)[r_symndx];
8455
8456                       for (; ent != NULL; ent = ent->next)
8457                         if (ent->addend == rel->r_addend
8458                             && ent->owner == ibfd
8459                             && ent->tls_type == tls_type)
8460                           break;
8461                       if (ent == NULL)
8462                         abort ();
8463
8464                       if (tls_set == 0)
8465                         {
8466                           /* We managed to get rid of a got entry.  */
8467                           if (ent->got.refcount > 0)
8468                             ent->got.refcount -= 1;
8469                         }
8470                     }
8471                   else
8472                     {
8473                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8474                          we'll lose one or two dyn relocs.  */
8475                       if (!dec_dynrel_count (rel->r_info, sec, info,
8476                                              NULL, h, sym))
8477                         return FALSE;
8478
8479                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8480                         {
8481                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8482                                                  NULL, h, sym))
8483                             return FALSE;
8484                         }
8485                     }
8486
8487                   *tls_mask |= tls_set;
8488                   *tls_mask &= ~tls_clear;
8489                 }
8490
8491               if (elf_section_data (sec)->relocs != relstart)
8492                 free (relstart);
8493             }
8494
8495         if (locsyms != NULL
8496             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8497           {
8498             if (!info->keep_memory)
8499               free (locsyms);
8500             else
8501               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8502           }
8503       }
8504
8505   if (toc_ref != NULL)
8506     free (toc_ref);
8507   return TRUE;
8508 }
8509
8510 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8511    the values of any global symbols in a toc section that has been
8512    edited.  Globals in toc sections should be a rarity, so this function
8513    sets a flag if any are found in toc sections other than the one just
8514    edited, so that futher hash table traversals can be avoided.  */
8515
8516 struct adjust_toc_info
8517 {
8518   asection *toc;
8519   unsigned long *skip;
8520   bfd_boolean global_toc_syms;
8521 };
8522
8523 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8524
8525 static bfd_boolean
8526 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8527 {
8528   struct ppc_link_hash_entry *eh;
8529   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8530   unsigned long i;
8531
8532   if (h->root.type != bfd_link_hash_defined
8533       && h->root.type != bfd_link_hash_defweak)
8534     return TRUE;
8535
8536   eh = (struct ppc_link_hash_entry *) h;
8537   if (eh->adjust_done)
8538     return TRUE;
8539
8540   if (eh->elf.root.u.def.section == toc_inf->toc)
8541     {
8542       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8543         i = toc_inf->toc->rawsize >> 3;
8544       else
8545         i = eh->elf.root.u.def.value >> 3;
8546
8547       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8548         {
8549           (*_bfd_error_handler)
8550             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8551           do
8552             ++i;
8553           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8554           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8555         }
8556
8557       eh->elf.root.u.def.value -= toc_inf->skip[i];
8558       eh->adjust_done = 1;
8559     }
8560   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8561     toc_inf->global_toc_syms = TRUE;
8562
8563   return TRUE;
8564 }
8565
8566 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8567
8568 static bfd_boolean
8569 ok_lo_toc_insn (unsigned int insn)
8570 {
8571   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8572           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8573           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8574           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8575           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8576           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8577           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8578           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8579           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8580           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8581           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8582           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8583           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8584           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8585           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8586               && (insn & 3) != 1)
8587           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8588               && ((insn & 3) == 0 || (insn & 3) == 3))
8589           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8590 }
8591
8592 /* Examine all relocs referencing .toc sections in order to remove
8593    unused .toc entries.  */
8594
8595 bfd_boolean
8596 ppc64_elf_edit_toc (struct bfd_link_info *info)
8597 {
8598   bfd *ibfd;
8599   struct adjust_toc_info toc_inf;
8600   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8601
8602   htab->do_toc_opt = 1;
8603   toc_inf.global_toc_syms = TRUE;
8604   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8605     {
8606       asection *toc, *sec;
8607       Elf_Internal_Shdr *symtab_hdr;
8608       Elf_Internal_Sym *local_syms;
8609       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8610       unsigned long *skip, *drop;
8611       unsigned char *used;
8612       unsigned char *keep, last, some_unused;
8613
8614       if (!is_ppc64_elf (ibfd))
8615         continue;
8616
8617       toc = bfd_get_section_by_name (ibfd, ".toc");
8618       if (toc == NULL
8619           || toc->size == 0
8620           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8621           || discarded_section (toc))
8622         continue;
8623
8624       toc_relocs = NULL;
8625       local_syms = NULL;
8626       symtab_hdr = &elf_symtab_hdr (ibfd);
8627
8628       /* Look at sections dropped from the final link.  */
8629       skip = NULL;
8630       relstart = NULL;
8631       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8632         {
8633           if (sec->reloc_count == 0
8634               || !discarded_section (sec)
8635               || get_opd_info (sec)
8636               || (sec->flags & SEC_ALLOC) == 0
8637               || (sec->flags & SEC_DEBUGGING) != 0)
8638             continue;
8639
8640           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8641           if (relstart == NULL)
8642             goto error_ret;
8643
8644           /* Run through the relocs to see which toc entries might be
8645              unused.  */
8646           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8647             {
8648               enum elf_ppc64_reloc_type r_type;
8649               unsigned long r_symndx;
8650               asection *sym_sec;
8651               struct elf_link_hash_entry *h;
8652               Elf_Internal_Sym *sym;
8653               bfd_vma val;
8654
8655               r_type = ELF64_R_TYPE (rel->r_info);
8656               switch (r_type)
8657                 {
8658                 default:
8659                   continue;
8660
8661                 case R_PPC64_TOC16:
8662                 case R_PPC64_TOC16_LO:
8663                 case R_PPC64_TOC16_HI:
8664                 case R_PPC64_TOC16_HA:
8665                 case R_PPC64_TOC16_DS:
8666                 case R_PPC64_TOC16_LO_DS:
8667                   break;
8668                 }
8669
8670               r_symndx = ELF64_R_SYM (rel->r_info);
8671               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8672                               r_symndx, ibfd))
8673                 goto error_ret;
8674
8675               if (sym_sec != toc)
8676                 continue;
8677
8678               if (h != NULL)
8679                 val = h->root.u.def.value;
8680               else
8681                 val = sym->st_value;
8682               val += rel->r_addend;
8683
8684               if (val >= toc->size)
8685                 continue;
8686
8687               /* Anything in the toc ought to be aligned to 8 bytes.
8688                  If not, don't mark as unused.  */
8689               if (val & 7)
8690                 continue;
8691
8692               if (skip == NULL)
8693                 {
8694                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8695                   if (skip == NULL)
8696                     goto error_ret;
8697                 }
8698
8699               skip[val >> 3] = ref_from_discarded;
8700             }
8701
8702           if (elf_section_data (sec)->relocs != relstart)
8703             free (relstart);
8704         }
8705
8706       /* For largetoc loads of address constants, we can convert
8707          .  addis rx,2,addr@got@ha
8708          .  ld ry,addr@got@l(rx)
8709          to
8710          .  addis rx,2,addr@toc@ha
8711          .  addi ry,rx,addr@toc@l
8712          when addr is within 2G of the toc pointer.  This then means
8713          that the word storing "addr" in the toc is no longer needed.  */
8714
8715       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8716           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8717           && toc->reloc_count != 0)
8718         {
8719           /* Read toc relocs.  */
8720           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8721                                                   info->keep_memory);
8722           if (toc_relocs == NULL)
8723             goto error_ret;
8724
8725           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8726             {
8727               enum elf_ppc64_reloc_type r_type;
8728               unsigned long r_symndx;
8729               asection *sym_sec;
8730               struct elf_link_hash_entry *h;
8731               Elf_Internal_Sym *sym;
8732               bfd_vma val, addr;
8733
8734               r_type = ELF64_R_TYPE (rel->r_info);
8735               if (r_type != R_PPC64_ADDR64)
8736                 continue;
8737
8738               r_symndx = ELF64_R_SYM (rel->r_info);
8739               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8740                               r_symndx, ibfd))
8741                 goto error_ret;
8742
8743               if (sym_sec == NULL
8744                   || discarded_section (sym_sec))
8745                 continue;
8746
8747               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8748                 continue;
8749
8750               if (h != NULL)
8751                 {
8752                   if (h->type == STT_GNU_IFUNC)
8753                     continue;
8754                   val = h->root.u.def.value;
8755                 }
8756               else
8757                 {
8758                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8759                     continue;
8760                   val = sym->st_value;
8761                 }
8762               val += rel->r_addend;
8763               val += sym_sec->output_section->vma + sym_sec->output_offset;
8764
8765               /* We don't yet know the exact toc pointer value, but we
8766                  know it will be somewhere in the toc section.  Don't
8767                  optimize if the difference from any possible toc
8768                  pointer is outside [ff..f80008000, 7fff7fff].  */
8769               addr = toc->output_section->vma + TOC_BASE_OFF;
8770               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8771                 continue;
8772
8773               addr = toc->output_section->vma + toc->output_section->rawsize;
8774               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8775                 continue;
8776
8777               if (skip == NULL)
8778                 {
8779                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8780                   if (skip == NULL)
8781                     goto error_ret;
8782                 }
8783
8784               skip[rel->r_offset >> 3]
8785                 |= can_optimize | ((rel - toc_relocs) << 2);
8786             }
8787         }
8788
8789       if (skip == NULL)
8790         continue;
8791
8792       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8793       if (used == NULL)
8794         {
8795         error_ret:
8796           if (local_syms != NULL
8797               && symtab_hdr->contents != (unsigned char *) local_syms)
8798             free (local_syms);
8799           if (sec != NULL
8800               && relstart != NULL
8801               && elf_section_data (sec)->relocs != relstart)
8802             free (relstart);
8803           if (toc_relocs != NULL
8804               && elf_section_data (toc)->relocs != toc_relocs)
8805             free (toc_relocs);
8806           if (skip != NULL)
8807             free (skip);
8808           return FALSE;
8809         }
8810
8811       /* Now check all kept sections that might reference the toc.
8812          Check the toc itself last.  */
8813       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8814                   : ibfd->sections);
8815            sec != NULL;
8816            sec = (sec == toc ? NULL
8817                   : sec->next == NULL ? toc
8818                   : sec->next == toc && toc->next ? toc->next
8819                   : sec->next))
8820         {
8821           int repeat;
8822
8823           if (sec->reloc_count == 0
8824               || discarded_section (sec)
8825               || get_opd_info (sec)
8826               || (sec->flags & SEC_ALLOC) == 0
8827               || (sec->flags & SEC_DEBUGGING) != 0)
8828             continue;
8829
8830           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8831                                                 info->keep_memory);
8832           if (relstart == NULL)
8833             {
8834               free (used);
8835               goto error_ret;
8836             }
8837
8838           /* Mark toc entries referenced as used.  */
8839           do
8840             {
8841               repeat = 0;
8842               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8843                 {
8844                   enum elf_ppc64_reloc_type r_type;
8845                   unsigned long r_symndx;
8846                   asection *sym_sec;
8847                   struct elf_link_hash_entry *h;
8848                   Elf_Internal_Sym *sym;
8849                   bfd_vma val;
8850                   enum {no_check, check_lo, check_ha} insn_check;
8851
8852                   r_type = ELF64_R_TYPE (rel->r_info);
8853                   switch (r_type)
8854                     {
8855                     default:
8856                       insn_check = no_check;
8857                       break;
8858
8859                     case R_PPC64_GOT_TLSLD16_HA:
8860                     case R_PPC64_GOT_TLSGD16_HA:
8861                     case R_PPC64_GOT_TPREL16_HA:
8862                     case R_PPC64_GOT_DTPREL16_HA:
8863                     case R_PPC64_GOT16_HA:
8864                     case R_PPC64_TOC16_HA:
8865                       insn_check = check_ha;
8866                       break;
8867
8868                     case R_PPC64_GOT_TLSLD16_LO:
8869                     case R_PPC64_GOT_TLSGD16_LO:
8870                     case R_PPC64_GOT_TPREL16_LO_DS:
8871                     case R_PPC64_GOT_DTPREL16_LO_DS:
8872                     case R_PPC64_GOT16_LO:
8873                     case R_PPC64_GOT16_LO_DS:
8874                     case R_PPC64_TOC16_LO:
8875                     case R_PPC64_TOC16_LO_DS:
8876                       insn_check = check_lo;
8877                       break;
8878                     }
8879
8880                   if (insn_check != no_check)
8881                     {
8882                       bfd_vma off = rel->r_offset & ~3;
8883                       unsigned char buf[4];
8884                       unsigned int insn;
8885
8886                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8887                         {
8888                           free (used);
8889                           goto error_ret;
8890                         }
8891                       insn = bfd_get_32 (ibfd, buf);
8892                       if (insn_check == check_lo
8893                           ? !ok_lo_toc_insn (insn)
8894                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8895                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8896                         {
8897                           char str[12];
8898
8899                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8900                           sprintf (str, "%#08x", insn);
8901                           info->callbacks->einfo
8902                             (_("%P: %H: toc optimization is not supported for"
8903                                " %s instruction.\n"),
8904                              ibfd, sec, rel->r_offset & ~3, str);
8905                         }
8906                     }
8907
8908                   switch (r_type)
8909                     {
8910                     case R_PPC64_TOC16:
8911                     case R_PPC64_TOC16_LO:
8912                     case R_PPC64_TOC16_HI:
8913                     case R_PPC64_TOC16_HA:
8914                     case R_PPC64_TOC16_DS:
8915                     case R_PPC64_TOC16_LO_DS:
8916                       /* In case we're taking addresses of toc entries.  */
8917                     case R_PPC64_ADDR64:
8918                       break;
8919
8920                     default:
8921                       continue;
8922                     }
8923
8924                   r_symndx = ELF64_R_SYM (rel->r_info);
8925                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8926                                   r_symndx, ibfd))
8927                     {
8928                       free (used);
8929                       goto error_ret;
8930                     }
8931
8932                   if (sym_sec != toc)
8933                     continue;
8934
8935                   if (h != NULL)
8936                     val = h->root.u.def.value;
8937                   else
8938                     val = sym->st_value;
8939                   val += rel->r_addend;
8940
8941                   if (val >= toc->size)
8942                     continue;
8943
8944                   if ((skip[val >> 3] & can_optimize) != 0)
8945                     {
8946                       bfd_vma off;
8947                       unsigned char opc;
8948
8949                       switch (r_type)
8950                         {
8951                         case R_PPC64_TOC16_HA:
8952                           break;
8953
8954                         case R_PPC64_TOC16_LO_DS:
8955                           off = rel->r_offset;
8956                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8957                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8958                                                          off, 1))
8959                             {
8960                               free (used);
8961                               goto error_ret;
8962                             }
8963                           if ((opc & (0x3f << 2)) == (58u << 2))
8964                             break;
8965                           /* Fall thru */
8966
8967                         default:
8968                           /* Wrong sort of reloc, or not a ld.  We may
8969                              as well clear ref_from_discarded too.  */
8970                           skip[val >> 3] = 0;
8971                         }
8972                     }
8973
8974                   if (sec != toc)
8975                     used[val >> 3] = 1;
8976                   /* For the toc section, we only mark as used if this
8977                      entry itself isn't unused.  */
8978                   else if ((used[rel->r_offset >> 3]
8979                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8980                            && !used[val >> 3])
8981                     {
8982                       /* Do all the relocs again, to catch reference
8983                          chains.  */
8984                       repeat = 1;
8985                       used[val >> 3] = 1;
8986                     }
8987                 }
8988             }
8989           while (repeat);
8990
8991           if (elf_section_data (sec)->relocs != relstart)
8992             free (relstart);
8993         }
8994
8995       /* Merge the used and skip arrays.  Assume that TOC
8996          doublewords not appearing as either used or unused belong
8997          to to an entry more than one doubleword in size.  */
8998       for (drop = skip, keep = used, last = 0, some_unused = 0;
8999            drop < skip + (toc->size + 7) / 8;
9000            ++drop, ++keep)
9001         {
9002           if (*keep)
9003             {
9004               *drop &= ~ref_from_discarded;
9005               if ((*drop & can_optimize) != 0)
9006                 some_unused = 1;
9007               last = 0;
9008             }
9009           else if ((*drop & ref_from_discarded) != 0)
9010             {
9011               some_unused = 1;
9012               last = ref_from_discarded;
9013             }
9014           else
9015             *drop = last;
9016         }
9017
9018       free (used);
9019
9020       if (some_unused)
9021         {
9022           bfd_byte *contents, *src;
9023           unsigned long off;
9024           Elf_Internal_Sym *sym;
9025           bfd_boolean local_toc_syms = FALSE;
9026
9027           /* Shuffle the toc contents, and at the same time convert the
9028              skip array from booleans into offsets.  */
9029           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9030             goto error_ret;
9031
9032           elf_section_data (toc)->this_hdr.contents = contents;
9033
9034           for (src = contents, off = 0, drop = skip;
9035                src < contents + toc->size;
9036                src += 8, ++drop)
9037             {
9038               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9039                 off += 8;
9040               else if (off != 0)
9041                 {
9042                   *drop = off;
9043                   memcpy (src - off, src, 8);
9044                 }
9045             }
9046           *drop = off;
9047           toc->rawsize = toc->size;
9048           toc->size = src - contents - off;
9049
9050           /* Adjust addends for relocs against the toc section sym,
9051              and optimize any accesses we can.  */
9052           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9053             {
9054               if (sec->reloc_count == 0
9055                   || discarded_section (sec))
9056                 continue;
9057
9058               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9059                                                     info->keep_memory);
9060               if (relstart == NULL)
9061                 goto error_ret;
9062
9063               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9064                 {
9065                   enum elf_ppc64_reloc_type r_type;
9066                   unsigned long r_symndx;
9067                   asection *sym_sec;
9068                   struct elf_link_hash_entry *h;
9069                   bfd_vma val;
9070
9071                   r_type = ELF64_R_TYPE (rel->r_info);
9072                   switch (r_type)
9073                     {
9074                     default:
9075                       continue;
9076
9077                     case R_PPC64_TOC16:
9078                     case R_PPC64_TOC16_LO:
9079                     case R_PPC64_TOC16_HI:
9080                     case R_PPC64_TOC16_HA:
9081                     case R_PPC64_TOC16_DS:
9082                     case R_PPC64_TOC16_LO_DS:
9083                     case R_PPC64_ADDR64:
9084                       break;
9085                     }
9086
9087                   r_symndx = ELF64_R_SYM (rel->r_info);
9088                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9089                                   r_symndx, ibfd))
9090                     goto error_ret;
9091
9092                   if (sym_sec != toc)
9093                     continue;
9094
9095                   if (h != NULL)
9096                     val = h->root.u.def.value;
9097                   else
9098                     {
9099                       val = sym->st_value;
9100                       if (val != 0)
9101                         local_toc_syms = TRUE;
9102                     }
9103
9104                   val += rel->r_addend;
9105
9106                   if (val > toc->rawsize)
9107                     val = toc->rawsize;
9108                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9109                     continue;
9110                   else if ((skip[val >> 3] & can_optimize) != 0)
9111                     {
9112                       Elf_Internal_Rela *tocrel
9113                         = toc_relocs + (skip[val >> 3] >> 2);
9114                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9115
9116                       switch (r_type)
9117                         {
9118                         case R_PPC64_TOC16_HA:
9119                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9120                           break;
9121
9122                         case R_PPC64_TOC16_LO_DS:
9123                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9124                           break;
9125
9126                         default:
9127                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9128                             ppc_howto_init ();
9129                           info->callbacks->einfo
9130                             (_("%P: %H: %s references "
9131                                "optimized away TOC entry\n"),
9132                              ibfd, sec, rel->r_offset,
9133                              ppc64_elf_howto_table[r_type]->name);
9134                           bfd_set_error (bfd_error_bad_value);
9135                           goto error_ret;
9136                         }
9137                       rel->r_addend = tocrel->r_addend;
9138                       elf_section_data (sec)->relocs = relstart;
9139                       continue;
9140                     }
9141
9142                   if (h != NULL || sym->st_value != 0)
9143                     continue;
9144
9145                   rel->r_addend -= skip[val >> 3];
9146                   elf_section_data (sec)->relocs = relstart;
9147                 }
9148
9149               if (elf_section_data (sec)->relocs != relstart)
9150                 free (relstart);
9151             }
9152
9153           /* We shouldn't have local or global symbols defined in the TOC,
9154              but handle them anyway.  */
9155           if (local_syms != NULL)
9156             for (sym = local_syms;
9157                  sym < local_syms + symtab_hdr->sh_info;
9158                  ++sym)
9159               if (sym->st_value != 0
9160                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9161                 {
9162                   unsigned long i;
9163
9164                   if (sym->st_value > toc->rawsize)
9165                     i = toc->rawsize >> 3;
9166                   else
9167                     i = sym->st_value >> 3;
9168
9169                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9170                     {
9171                       if (local_toc_syms)
9172                         (*_bfd_error_handler)
9173                           (_("%s defined on removed toc entry"),
9174                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9175                       do
9176                         ++i;
9177                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9178                       sym->st_value = (bfd_vma) i << 3;
9179                     }
9180
9181                   sym->st_value -= skip[i];
9182                   symtab_hdr->contents = (unsigned char *) local_syms;
9183                 }
9184
9185           /* Adjust any global syms defined in this toc input section.  */
9186           if (toc_inf.global_toc_syms)
9187             {
9188               toc_inf.toc = toc;
9189               toc_inf.skip = skip;
9190               toc_inf.global_toc_syms = FALSE;
9191               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9192                                       &toc_inf);
9193             }
9194
9195           if (toc->reloc_count != 0)
9196             {
9197               Elf_Internal_Shdr *rel_hdr;
9198               Elf_Internal_Rela *wrel;
9199               bfd_size_type sz;
9200
9201               /* Remove unused toc relocs, and adjust those we keep.  */
9202               if (toc_relocs == NULL)
9203                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9204                                                         info->keep_memory);
9205               if (toc_relocs == NULL)
9206                 goto error_ret;
9207
9208               wrel = toc_relocs;
9209               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9210                 if ((skip[rel->r_offset >> 3]
9211                      & (ref_from_discarded | can_optimize)) == 0)
9212                   {
9213                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9214                     wrel->r_info = rel->r_info;
9215                     wrel->r_addend = rel->r_addend;
9216                     ++wrel;
9217                   }
9218                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9219                                             &local_syms, NULL, NULL))
9220                   goto error_ret;
9221
9222               elf_section_data (toc)->relocs = toc_relocs;
9223               toc->reloc_count = wrel - toc_relocs;
9224               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9225               sz = rel_hdr->sh_entsize;
9226               rel_hdr->sh_size = toc->reloc_count * sz;
9227             }
9228         }
9229       else if (toc_relocs != NULL
9230                && elf_section_data (toc)->relocs != toc_relocs)
9231         free (toc_relocs);
9232
9233       if (local_syms != NULL
9234           && symtab_hdr->contents != (unsigned char *) local_syms)
9235         {
9236           if (!info->keep_memory)
9237             free (local_syms);
9238           else
9239             symtab_hdr->contents = (unsigned char *) local_syms;
9240         }
9241       free (skip);
9242     }
9243
9244   return TRUE;
9245 }
9246
9247 /* Return true iff input section I references the TOC using
9248    instructions limited to +/-32k offsets.  */
9249
9250 bfd_boolean
9251 ppc64_elf_has_small_toc_reloc (asection *i)
9252 {
9253   return (is_ppc64_elf (i->owner)
9254           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9255 }
9256
9257 /* Allocate space for one GOT entry.  */
9258
9259 static void
9260 allocate_got (struct elf_link_hash_entry *h,
9261               struct bfd_link_info *info,
9262               struct got_entry *gent)
9263 {
9264   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9265   bfd_boolean dyn;
9266   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9267   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9268                  ? 16 : 8);
9269   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9270                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9271   asection *got = ppc64_elf_tdata (gent->owner)->got;
9272
9273   gent->got.offset = got->size;
9274   got->size += entsize;
9275
9276   dyn = htab->elf.dynamic_sections_created;
9277   if (h->type == STT_GNU_IFUNC)
9278     {
9279       htab->elf.irelplt->size += rentsize;
9280       htab->got_reli_size += rentsize;
9281     }
9282   else if ((info->shared
9283             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9284            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9285                || h->root.type != bfd_link_hash_undefweak))
9286     {
9287       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9288       relgot->size += rentsize;
9289     }
9290 }
9291
9292 /* This function merges got entries in the same toc group.  */
9293
9294 static void
9295 merge_got_entries (struct got_entry **pent)
9296 {
9297   struct got_entry *ent, *ent2;
9298
9299   for (ent = *pent; ent != NULL; ent = ent->next)
9300     if (!ent->is_indirect)
9301       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9302         if (!ent2->is_indirect
9303             && ent2->addend == ent->addend
9304             && ent2->tls_type == ent->tls_type
9305             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9306           {
9307             ent2->is_indirect = TRUE;
9308             ent2->got.ent = ent;
9309           }
9310 }
9311
9312 /* Allocate space in .plt, .got and associated reloc sections for
9313    dynamic relocs.  */
9314
9315 static bfd_boolean
9316 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9317 {
9318   struct bfd_link_info *info;
9319   struct ppc_link_hash_table *htab;
9320   asection *s;
9321   struct ppc_link_hash_entry *eh;
9322   struct elf_dyn_relocs *p;
9323   struct got_entry **pgent, *gent;
9324
9325   if (h->root.type == bfd_link_hash_indirect)
9326     return TRUE;
9327
9328   info = (struct bfd_link_info *) inf;
9329   htab = ppc_hash_table (info);
9330   if (htab == NULL)
9331     return FALSE;
9332
9333   if ((htab->elf.dynamic_sections_created
9334        && h->dynindx != -1
9335        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9336       || h->type == STT_GNU_IFUNC)
9337     {
9338       struct plt_entry *pent;
9339       bfd_boolean doneone = FALSE;
9340       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9341         if (pent->plt.refcount > 0)
9342           {
9343             if (!htab->elf.dynamic_sections_created
9344                 || h->dynindx == -1)
9345               {
9346                 s = htab->elf.iplt;
9347                 pent->plt.offset = s->size;
9348                 s->size += PLT_ENTRY_SIZE (htab);
9349                 s = htab->elf.irelplt;
9350               }
9351             else
9352               {
9353                 /* If this is the first .plt entry, make room for the special
9354                    first entry.  */
9355                 s = htab->elf.splt;
9356                 if (s->size == 0)
9357                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9358
9359                 pent->plt.offset = s->size;
9360
9361                 /* Make room for this entry.  */
9362                 s->size += PLT_ENTRY_SIZE (htab);
9363
9364                 /* Make room for the .glink code.  */
9365                 s = htab->glink;
9366                 if (s->size == 0)
9367                   s->size += GLINK_CALL_STUB_SIZE;
9368                 if (htab->opd_abi)
9369                   {
9370                     /* We need bigger stubs past index 32767.  */
9371                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9372                       s->size += 4;
9373                     s->size += 2*4;
9374                   }
9375                 else
9376                   s->size += 4;
9377
9378                 /* We also need to make an entry in the .rela.plt section.  */
9379                 s = htab->elf.srelplt;
9380               }
9381             s->size += sizeof (Elf64_External_Rela);
9382             doneone = TRUE;
9383           }
9384         else
9385           pent->plt.offset = (bfd_vma) -1;
9386       if (!doneone)
9387         {
9388           h->plt.plist = NULL;
9389           h->needs_plt = 0;
9390         }
9391     }
9392   else
9393     {
9394       h->plt.plist = NULL;
9395       h->needs_plt = 0;
9396     }
9397
9398   eh = (struct ppc_link_hash_entry *) h;
9399   /* Run through the TLS GD got entries first if we're changing them
9400      to TPREL.  */
9401   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9402     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9403       if (gent->got.refcount > 0
9404           && (gent->tls_type & TLS_GD) != 0)
9405         {
9406           /* This was a GD entry that has been converted to TPREL.  If
9407              there happens to be a TPREL entry we can use that one.  */
9408           struct got_entry *ent;
9409           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9410             if (ent->got.refcount > 0
9411                 && (ent->tls_type & TLS_TPREL) != 0
9412                 && ent->addend == gent->addend
9413                 && ent->owner == gent->owner)
9414               {
9415                 gent->got.refcount = 0;
9416                 break;
9417               }
9418
9419           /* If not, then we'll be using our own TPREL entry.  */
9420           if (gent->got.refcount != 0)
9421             gent->tls_type = TLS_TLS | TLS_TPREL;
9422         }
9423
9424   /* Remove any list entry that won't generate a word in the GOT before
9425      we call merge_got_entries.  Otherwise we risk merging to empty
9426      entries.  */
9427   pgent = &h->got.glist;
9428   while ((gent = *pgent) != NULL)
9429     if (gent->got.refcount > 0)
9430       {
9431         if ((gent->tls_type & TLS_LD) != 0
9432             && !h->def_dynamic)
9433           {
9434             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9435             *pgent = gent->next;
9436           }
9437         else
9438           pgent = &gent->next;
9439       }
9440     else
9441       *pgent = gent->next;
9442
9443   if (!htab->do_multi_toc)
9444     merge_got_entries (&h->got.glist);
9445
9446   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9447     if (!gent->is_indirect)
9448       {
9449         /* Make sure this symbol is output as a dynamic symbol.
9450            Undefined weak syms won't yet be marked as dynamic,
9451            nor will all TLS symbols.  */
9452         if (h->dynindx == -1
9453             && !h->forced_local
9454             && h->type != STT_GNU_IFUNC
9455             && htab->elf.dynamic_sections_created)
9456           {
9457             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9458               return FALSE;
9459           }
9460
9461         if (!is_ppc64_elf (gent->owner))
9462           abort ();
9463
9464         allocate_got (h, info, gent);
9465       }
9466
9467   if (eh->dyn_relocs == NULL
9468       || (!htab->elf.dynamic_sections_created
9469           && h->type != STT_GNU_IFUNC))
9470     return TRUE;
9471
9472   /* In the shared -Bsymbolic case, discard space allocated for
9473      dynamic pc-relative relocs against symbols which turn out to be
9474      defined in regular objects.  For the normal shared case, discard
9475      space for relocs that have become local due to symbol visibility
9476      changes.  */
9477
9478   if (info->shared)
9479     {
9480       /* Relocs that use pc_count are those that appear on a call insn,
9481          or certain REL relocs (see must_be_dyn_reloc) that can be
9482          generated via assembly.  We want calls to protected symbols to
9483          resolve directly to the function rather than going via the plt.
9484          If people want function pointer comparisons to work as expected
9485          then they should avoid writing weird assembly.  */
9486       if (SYMBOL_CALLS_LOCAL (info, h))
9487         {
9488           struct elf_dyn_relocs **pp;
9489
9490           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9491             {
9492               p->count -= p->pc_count;
9493               p->pc_count = 0;
9494               if (p->count == 0)
9495                 *pp = p->next;
9496               else
9497                 pp = &p->next;
9498             }
9499         }
9500
9501       /* Also discard relocs on undefined weak syms with non-default
9502          visibility.  */
9503       if (eh->dyn_relocs != NULL
9504           && h->root.type == bfd_link_hash_undefweak)
9505         {
9506           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9507             eh->dyn_relocs = NULL;
9508
9509           /* Make sure this symbol is output as a dynamic symbol.
9510              Undefined weak syms won't yet be marked as dynamic.  */
9511           else if (h->dynindx == -1
9512                    && !h->forced_local)
9513             {
9514               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9515                 return FALSE;
9516             }
9517         }
9518     }
9519   else if (h->type == STT_GNU_IFUNC)
9520     {
9521       if (!h->non_got_ref)
9522         eh->dyn_relocs = NULL;
9523     }
9524   else if (ELIMINATE_COPY_RELOCS)
9525     {
9526       /* For the non-shared case, discard space for relocs against
9527          symbols which turn out to need copy relocs or are not
9528          dynamic.  */
9529
9530       if (!h->non_got_ref
9531           && !h->def_regular)
9532         {
9533           /* Make sure this symbol is output as a dynamic symbol.
9534              Undefined weak syms won't yet be marked as dynamic.  */
9535           if (h->dynindx == -1
9536               && !h->forced_local)
9537             {
9538               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9539                 return FALSE;
9540             }
9541
9542           /* If that succeeded, we know we'll be keeping all the
9543              relocs.  */
9544           if (h->dynindx != -1)
9545             goto keep;
9546         }
9547
9548       eh->dyn_relocs = NULL;
9549
9550     keep: ;
9551     }
9552
9553   /* Finally, allocate space.  */
9554   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9555     {
9556       asection *sreloc = elf_section_data (p->sec)->sreloc;
9557       if (eh->elf.type == STT_GNU_IFUNC)
9558         sreloc = htab->elf.irelplt;
9559       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9560     }
9561
9562   return TRUE;
9563 }
9564
9565 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9566    to set up space for global entry stubs.  These are put in glink,
9567    after the branch table.  */
9568
9569 static bfd_boolean
9570 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9571 {
9572   struct bfd_link_info *info;
9573   struct ppc_link_hash_table *htab;
9574   struct plt_entry *pent;
9575   asection *s;
9576
9577   if (h->root.type == bfd_link_hash_indirect)
9578     return TRUE;
9579
9580   if (!h->pointer_equality_needed)
9581     return TRUE;
9582
9583   if (h->def_regular)
9584     return TRUE;
9585
9586   info = inf;
9587   htab = ppc_hash_table (info);
9588   if (htab == NULL)
9589     return FALSE;
9590
9591   s = htab->glink;
9592   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9593     if (pent->plt.offset != (bfd_vma) -1
9594         && pent->addend == 0)
9595       {
9596         /* For ELFv2, if this symbol is not defined in a regular file
9597            and we are not generating a shared library or pie, then we
9598            need to define the symbol in the executable on a call stub.
9599            This is to avoid text relocations.  */
9600         s->size = (s->size + 15) & -16;
9601         h->root.u.def.section = s;
9602         h->root.u.def.value = s->size;
9603         s->size += 16;
9604         break;
9605       }
9606   return TRUE;
9607 }
9608
9609 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9610    read-only sections.  */
9611
9612 static bfd_boolean
9613 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9614 {
9615   if (h->root.type == bfd_link_hash_indirect)
9616     return TRUE;
9617
9618   if (readonly_dynrelocs (h))
9619     {
9620       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9621
9622       /* Not an error, just cut short the traversal.  */
9623       return FALSE;
9624     }
9625   return TRUE;
9626 }
9627
9628 /* Set the sizes of the dynamic sections.  */
9629
9630 static bfd_boolean
9631 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9632                                  struct bfd_link_info *info)
9633 {
9634   struct ppc_link_hash_table *htab;
9635   bfd *dynobj;
9636   asection *s;
9637   bfd_boolean relocs;
9638   bfd *ibfd;
9639   struct got_entry *first_tlsld;
9640
9641   htab = ppc_hash_table (info);
9642   if (htab == NULL)
9643     return FALSE;
9644
9645   dynobj = htab->elf.dynobj;
9646   if (dynobj == NULL)
9647     abort ();
9648
9649   if (htab->elf.dynamic_sections_created)
9650     {
9651       /* Set the contents of the .interp section to the interpreter.  */
9652       if (info->executable)
9653         {
9654           s = bfd_get_linker_section (dynobj, ".interp");
9655           if (s == NULL)
9656             abort ();
9657           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9658           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9659         }
9660     }
9661
9662   /* Set up .got offsets for local syms, and space for local dynamic
9663      relocs.  */
9664   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9665     {
9666       struct got_entry **lgot_ents;
9667       struct got_entry **end_lgot_ents;
9668       struct plt_entry **local_plt;
9669       struct plt_entry **end_local_plt;
9670       unsigned char *lgot_masks;
9671       bfd_size_type locsymcount;
9672       Elf_Internal_Shdr *symtab_hdr;
9673
9674       if (!is_ppc64_elf (ibfd))
9675         continue;
9676
9677       for (s = ibfd->sections; s != NULL; s = s->next)
9678         {
9679           struct ppc_dyn_relocs *p;
9680
9681           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9682             {
9683               if (!bfd_is_abs_section (p->sec)
9684                   && bfd_is_abs_section (p->sec->output_section))
9685                 {
9686                   /* Input section has been discarded, either because
9687                      it is a copy of a linkonce section or due to
9688                      linker script /DISCARD/, so we'll be discarding
9689                      the relocs too.  */
9690                 }
9691               else if (p->count != 0)
9692                 {
9693                   asection *srel = elf_section_data (p->sec)->sreloc;
9694                   if (p->ifunc)
9695                     srel = htab->elf.irelplt;
9696                   srel->size += p->count * sizeof (Elf64_External_Rela);
9697                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9698                     info->flags |= DF_TEXTREL;
9699                 }
9700             }
9701         }
9702
9703       lgot_ents = elf_local_got_ents (ibfd);
9704       if (!lgot_ents)
9705         continue;
9706
9707       symtab_hdr = &elf_symtab_hdr (ibfd);
9708       locsymcount = symtab_hdr->sh_info;
9709       end_lgot_ents = lgot_ents + locsymcount;
9710       local_plt = (struct plt_entry **) end_lgot_ents;
9711       end_local_plt = local_plt + locsymcount;
9712       lgot_masks = (unsigned char *) end_local_plt;
9713       s = ppc64_elf_tdata (ibfd)->got;
9714       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9715         {
9716           struct got_entry **pent, *ent;
9717
9718           pent = lgot_ents;
9719           while ((ent = *pent) != NULL)
9720             if (ent->got.refcount > 0)
9721               {
9722                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9723                   {
9724                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9725                     *pent = ent->next;
9726                   }
9727                 else
9728                   {
9729                     unsigned int ent_size = 8;
9730                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9731
9732                     ent->got.offset = s->size;
9733                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9734                       {
9735                         ent_size *= 2;
9736                         rel_size *= 2;
9737                       }
9738                     s->size += ent_size;
9739                     if ((*lgot_masks & PLT_IFUNC) != 0)
9740                       {
9741                         htab->elf.irelplt->size += rel_size;
9742                         htab->got_reli_size += rel_size;
9743                       }
9744                     else if (info->shared)
9745                       {
9746                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9747                         srel->size += rel_size;
9748                       }
9749                     pent = &ent->next;
9750                   }
9751               }
9752             else
9753               *pent = ent->next;
9754         }
9755
9756       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9757       for (; local_plt < end_local_plt; ++local_plt)
9758         {
9759           struct plt_entry *ent;
9760
9761           for (ent = *local_plt; ent != NULL; ent = ent->next)
9762             if (ent->plt.refcount > 0)
9763               {
9764                 s = htab->elf.iplt;
9765                 ent->plt.offset = s->size;
9766                 s->size += PLT_ENTRY_SIZE (htab);
9767
9768                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9769               }
9770             else
9771               ent->plt.offset = (bfd_vma) -1;
9772         }
9773     }
9774
9775   /* Allocate global sym .plt and .got entries, and space for global
9776      sym dynamic relocs.  */
9777   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9778   /* Stash the end of glink branch table.  */
9779   if (htab->glink != NULL)
9780     htab->glink->rawsize = htab->glink->size;
9781
9782   if (!htab->opd_abi && !info->shared)
9783     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9784
9785   first_tlsld = NULL;
9786   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9787     {
9788       struct got_entry *ent;
9789
9790       if (!is_ppc64_elf (ibfd))
9791         continue;
9792
9793       ent = ppc64_tlsld_got (ibfd);
9794       if (ent->got.refcount > 0)
9795         {
9796           if (!htab->do_multi_toc && first_tlsld != NULL)
9797             {
9798               ent->is_indirect = TRUE;
9799               ent->got.ent = first_tlsld;
9800             }
9801           else
9802             {
9803               if (first_tlsld == NULL)
9804                 first_tlsld = ent;
9805               s = ppc64_elf_tdata (ibfd)->got;
9806               ent->got.offset = s->size;
9807               ent->owner = ibfd;
9808               s->size += 16;
9809               if (info->shared)
9810                 {
9811                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9812                   srel->size += sizeof (Elf64_External_Rela);
9813                 }
9814             }
9815         }
9816       else
9817         ent->got.offset = (bfd_vma) -1;
9818     }
9819
9820   /* We now have determined the sizes of the various dynamic sections.
9821      Allocate memory for them.  */
9822   relocs = FALSE;
9823   for (s = dynobj->sections; s != NULL; s = s->next)
9824     {
9825       if ((s->flags & SEC_LINKER_CREATED) == 0)
9826         continue;
9827
9828       if (s == htab->brlt || s == htab->relbrlt)
9829         /* These haven't been allocated yet;  don't strip.  */
9830         continue;
9831       else if (s == htab->elf.sgot
9832                || s == htab->elf.splt
9833                || s == htab->elf.iplt
9834                || s == htab->glink
9835                || s == htab->dynbss)
9836         {
9837           /* Strip this section if we don't need it; see the
9838              comment below.  */
9839         }
9840       else if (s == htab->glink_eh_frame)
9841         {
9842           if (!bfd_is_abs_section (s->output_section))
9843             /* Not sized yet.  */
9844             continue;
9845         }
9846       else if (CONST_STRNEQ (s->name, ".rela"))
9847         {
9848           if (s->size != 0)
9849             {
9850               if (s != htab->elf.srelplt)
9851                 relocs = TRUE;
9852
9853               /* We use the reloc_count field as a counter if we need
9854                  to copy relocs into the output file.  */
9855               s->reloc_count = 0;
9856             }
9857         }
9858       else
9859         {
9860           /* It's not one of our sections, so don't allocate space.  */
9861           continue;
9862         }
9863
9864       if (s->size == 0)
9865         {
9866           /* If we don't need this section, strip it from the
9867              output file.  This is mostly to handle .rela.bss and
9868              .rela.plt.  We must create both sections in
9869              create_dynamic_sections, because they must be created
9870              before the linker maps input sections to output
9871              sections.  The linker does that before
9872              adjust_dynamic_symbol is called, and it is that
9873              function which decides whether anything needs to go
9874              into these sections.  */
9875           s->flags |= SEC_EXCLUDE;
9876           continue;
9877         }
9878
9879       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9880         continue;
9881
9882       /* Allocate memory for the section contents.  We use bfd_zalloc
9883          here in case unused entries are not reclaimed before the
9884          section's contents are written out.  This should not happen,
9885          but this way if it does we get a R_PPC64_NONE reloc in .rela
9886          sections instead of garbage.
9887          We also rely on the section contents being zero when writing
9888          the GOT.  */
9889       s->contents = bfd_zalloc (dynobj, s->size);
9890       if (s->contents == NULL)
9891         return FALSE;
9892     }
9893
9894   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9895     {
9896       if (!is_ppc64_elf (ibfd))
9897         continue;
9898
9899       s = ppc64_elf_tdata (ibfd)->got;
9900       if (s != NULL && s != htab->elf.sgot)
9901         {
9902           if (s->size == 0)
9903             s->flags |= SEC_EXCLUDE;
9904           else
9905             {
9906               s->contents = bfd_zalloc (ibfd, s->size);
9907               if (s->contents == NULL)
9908                 return FALSE;
9909             }
9910         }
9911       s = ppc64_elf_tdata (ibfd)->relgot;
9912       if (s != NULL)
9913         {
9914           if (s->size == 0)
9915             s->flags |= SEC_EXCLUDE;
9916           else
9917             {
9918               s->contents = bfd_zalloc (ibfd, s->size);
9919               if (s->contents == NULL)
9920                 return FALSE;
9921               relocs = TRUE;
9922               s->reloc_count = 0;
9923             }
9924         }
9925     }
9926
9927   if (htab->elf.dynamic_sections_created)
9928     {
9929       bfd_boolean tls_opt;
9930
9931       /* Add some entries to the .dynamic section.  We fill in the
9932          values later, in ppc64_elf_finish_dynamic_sections, but we
9933          must add the entries now so that we get the correct size for
9934          the .dynamic section.  The DT_DEBUG entry is filled in by the
9935          dynamic linker and used by the debugger.  */
9936 #define add_dynamic_entry(TAG, VAL) \
9937   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9938
9939       if (info->executable)
9940         {
9941           if (!add_dynamic_entry (DT_DEBUG, 0))
9942             return FALSE;
9943         }
9944
9945       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9946         {
9947           if (!add_dynamic_entry (DT_PLTGOT, 0)
9948               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9949               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9950               || !add_dynamic_entry (DT_JMPREL, 0)
9951               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9952             return FALSE;
9953         }
9954
9955       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9956         {
9957           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9958               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9959             return FALSE;
9960         }
9961
9962       tls_opt = (!htab->params->no_tls_get_addr_opt
9963                  && htab->tls_get_addr_fd != NULL
9964                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9965       if (tls_opt || !htab->opd_abi)
9966         {
9967           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9968             return FALSE;
9969         }
9970
9971       if (relocs)
9972         {
9973           if (!add_dynamic_entry (DT_RELA, 0)
9974               || !add_dynamic_entry (DT_RELASZ, 0)
9975               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9976             return FALSE;
9977
9978           /* If any dynamic relocs apply to a read-only section,
9979              then we need a DT_TEXTREL entry.  */
9980           if ((info->flags & DF_TEXTREL) == 0)
9981             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9982
9983           if ((info->flags & DF_TEXTREL) != 0)
9984             {
9985               if (!add_dynamic_entry (DT_TEXTREL, 0))
9986                 return FALSE;
9987             }
9988         }
9989     }
9990 #undef add_dynamic_entry
9991
9992   return TRUE;
9993 }
9994
9995 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9996
9997 static bfd_boolean
9998 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9999 {
10000   if (h->plt.plist != NULL
10001       && !h->def_regular
10002       && !h->pointer_equality_needed)
10003     return FALSE;
10004
10005   return _bfd_elf_hash_symbol (h);
10006 }
10007
10008 /* Determine the type of stub needed, if any, for a call.  */
10009
10010 static inline enum ppc_stub_type
10011 ppc_type_of_stub (asection *input_sec,
10012                   const Elf_Internal_Rela *rel,
10013                   struct ppc_link_hash_entry **hash,
10014                   struct plt_entry **plt_ent,
10015                   bfd_vma destination,
10016                   unsigned long local_off)
10017 {
10018   struct ppc_link_hash_entry *h = *hash;
10019   bfd_vma location;
10020   bfd_vma branch_offset;
10021   bfd_vma max_branch_offset;
10022   enum elf_ppc64_reloc_type r_type;
10023
10024   if (h != NULL)
10025     {
10026       struct plt_entry *ent;
10027       struct ppc_link_hash_entry *fdh = h;
10028       if (h->oh != NULL
10029           && h->oh->is_func_descriptor)
10030         {
10031           fdh = ppc_follow_link (h->oh);
10032           *hash = fdh;
10033         }
10034
10035       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10036         if (ent->addend == rel->r_addend
10037             && ent->plt.offset != (bfd_vma) -1)
10038           {
10039             *plt_ent = ent;
10040             return ppc_stub_plt_call;
10041           }
10042
10043       /* Here, we know we don't have a plt entry.  If we don't have a
10044          either a defined function descriptor or a defined entry symbol
10045          in a regular object file, then it is pointless trying to make
10046          any other type of stub.  */
10047       if (!is_static_defined (&fdh->elf)
10048           && !is_static_defined (&h->elf))
10049         return ppc_stub_none;
10050     }
10051   else if (elf_local_got_ents (input_sec->owner) != NULL)
10052     {
10053       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10054       struct plt_entry **local_plt = (struct plt_entry **)
10055         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10056       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10057
10058       if (local_plt[r_symndx] != NULL)
10059         {
10060           struct plt_entry *ent;
10061
10062           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10063             if (ent->addend == rel->r_addend
10064                 && ent->plt.offset != (bfd_vma) -1)
10065               {
10066                 *plt_ent = ent;
10067                 return ppc_stub_plt_call;
10068               }
10069         }
10070     }
10071
10072   /* Determine where the call point is.  */
10073   location = (input_sec->output_offset
10074               + input_sec->output_section->vma
10075               + rel->r_offset);
10076
10077   branch_offset = destination - location;
10078   r_type = ELF64_R_TYPE (rel->r_info);
10079
10080   /* Determine if a long branch stub is needed.  */
10081   max_branch_offset = 1 << 25;
10082   if (r_type != R_PPC64_REL24)
10083     max_branch_offset = 1 << 15;
10084
10085   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10086     /* We need a stub.  Figure out whether a long_branch or plt_branch
10087        is needed later.  */
10088     return ppc_stub_long_branch;
10089
10090   return ppc_stub_none;
10091 }
10092
10093 /* With power7 weakly ordered memory model, it is possible for ld.so
10094    to update a plt entry in one thread and have another thread see a
10095    stale zero toc entry.  To avoid this we need some sort of acquire
10096    barrier in the call stub.  One solution is to make the load of the
10097    toc word seem to appear to depend on the load of the function entry
10098    word.  Another solution is to test for r2 being zero, and branch to
10099    the appropriate glink entry if so.
10100
10101    .    fake dep barrier        compare
10102    .    ld 12,xxx(2)            ld 12,xxx(2)
10103    .    mtctr 12                mtctr 12
10104    .    xor 11,12,12            ld 2,xxx+8(2)
10105    .    add 2,2,11              cmpldi 2,0
10106    .    ld 2,xxx+8(2)           bnectr+
10107    .    bctr                    b <glink_entry>
10108
10109    The solution involving the compare turns out to be faster, so
10110    that's what we use unless the branch won't reach.  */
10111
10112 #define ALWAYS_USE_FAKE_DEP 0
10113 #define ALWAYS_EMIT_R2SAVE 0
10114
10115 #define PPC_LO(v) ((v) & 0xffff)
10116 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10117 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10118
10119 static inline unsigned int
10120 plt_stub_size (struct ppc_link_hash_table *htab,
10121                struct ppc_stub_hash_entry *stub_entry,
10122                bfd_vma off)
10123 {
10124   unsigned size = 12;
10125
10126   if (ALWAYS_EMIT_R2SAVE
10127       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10128     size += 4;
10129   if (PPC_HA (off) != 0)
10130     size += 4;
10131   if (htab->opd_abi)
10132     {
10133       size += 4;
10134       if (htab->params->plt_static_chain)
10135         size += 4;
10136       if (htab->params->plt_thread_safe)
10137         size += 8;
10138       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10139         size += 4;
10140     }
10141   if (stub_entry->h != NULL
10142       && (stub_entry->h == htab->tls_get_addr_fd
10143           || stub_entry->h == htab->tls_get_addr)
10144       && !htab->params->no_tls_get_addr_opt)
10145     size += 13 * 4;
10146   return size;
10147 }
10148
10149 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10150    then return the padding needed to do so.  */
10151 static inline unsigned int
10152 plt_stub_pad (struct ppc_link_hash_table *htab,
10153               struct ppc_stub_hash_entry *stub_entry,
10154               bfd_vma plt_off)
10155 {
10156   int stub_align = 1 << htab->params->plt_stub_align;
10157   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10158   bfd_vma stub_off = stub_entry->stub_sec->size;
10159
10160   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10161       > (stub_size & -stub_align))
10162     return stub_align - (stub_off & (stub_align - 1));
10163   return 0;
10164 }
10165
10166 /* Build a .plt call stub.  */
10167
10168 static inline bfd_byte *
10169 build_plt_stub (struct ppc_link_hash_table *htab,
10170                 struct ppc_stub_hash_entry *stub_entry,
10171                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10172 {
10173   bfd *obfd = htab->params->stub_bfd;
10174   bfd_boolean plt_load_toc = htab->opd_abi;
10175   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10176   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10177   bfd_boolean use_fake_dep = plt_thread_safe;
10178   bfd_vma cmp_branch_off = 0;
10179
10180   if (!ALWAYS_USE_FAKE_DEP
10181       && plt_load_toc
10182       && plt_thread_safe
10183       && !(stub_entry->h != NULL
10184            && (stub_entry->h == htab->tls_get_addr_fd
10185                || stub_entry->h == htab->tls_get_addr)
10186            && !htab->params->no_tls_get_addr_opt))
10187     {
10188       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10189       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10190                           / PLT_ENTRY_SIZE (htab));
10191       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10192       bfd_vma to, from;
10193
10194       if (pltindex > 32768)
10195         glinkoff += (pltindex - 32768) * 4;
10196       to = (glinkoff
10197             + htab->glink->output_offset
10198             + htab->glink->output_section->vma);
10199       from = (p - stub_entry->stub_sec->contents
10200               + 4 * (ALWAYS_EMIT_R2SAVE
10201                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10202               + 4 * (PPC_HA (offset) != 0)
10203               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10204                      != PPC_HA (offset))
10205               + 4 * (plt_static_chain != 0)
10206               + 20
10207               + stub_entry->stub_sec->output_offset
10208               + stub_entry->stub_sec->output_section->vma);
10209       cmp_branch_off = to - from;
10210       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10211     }
10212
10213   if (PPC_HA (offset) != 0)
10214     {
10215       if (r != NULL)
10216         {
10217           if (ALWAYS_EMIT_R2SAVE
10218               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10219             r[0].r_offset += 4;
10220           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10221           r[1].r_offset = r[0].r_offset + 4;
10222           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10223           r[1].r_addend = r[0].r_addend;
10224           if (plt_load_toc)
10225             {
10226               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10227                 {
10228                   r[2].r_offset = r[1].r_offset + 4;
10229                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10230                   r[2].r_addend = r[0].r_addend;
10231                 }
10232               else
10233                 {
10234                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10235                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10236                   r[2].r_addend = r[0].r_addend + 8;
10237                   if (plt_static_chain)
10238                     {
10239                       r[3].r_offset = r[2].r_offset + 4;
10240                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10241                       r[3].r_addend = r[0].r_addend + 16;
10242                     }
10243                 }
10244             }
10245         }
10246       if (ALWAYS_EMIT_R2SAVE
10247           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10248         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10249       if (plt_load_toc)
10250         {
10251           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10252           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10253         }
10254       else
10255         {
10256           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10257           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10258         }
10259       if (plt_load_toc
10260           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10261         {
10262           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10263           offset = 0;
10264         }
10265       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10266       if (plt_load_toc)
10267         {
10268           if (use_fake_dep)
10269             {
10270               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10271               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10272             }
10273           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10274           if (plt_static_chain)
10275             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10276         }
10277     }
10278   else
10279     {
10280       if (r != NULL)
10281         {
10282           if (ALWAYS_EMIT_R2SAVE
10283               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10284             r[0].r_offset += 4;
10285           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10286           if (plt_load_toc)
10287             {
10288               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10289                 {
10290                   r[1].r_offset = r[0].r_offset + 4;
10291                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10292                   r[1].r_addend = r[0].r_addend;
10293                 }
10294               else
10295                 {
10296                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10297                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10298                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10299                   if (plt_static_chain)
10300                     {
10301                       r[2].r_offset = r[1].r_offset + 4;
10302                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10303                       r[2].r_addend = r[0].r_addend + 8;
10304                     }
10305                 }
10306             }
10307         }
10308       if (ALWAYS_EMIT_R2SAVE
10309           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10310         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10311       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10312       if (plt_load_toc
10313           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10314         {
10315           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10316           offset = 0;
10317         }
10318       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10319       if (plt_load_toc)
10320         {
10321           if (use_fake_dep)
10322             {
10323               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10324               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10325             }
10326           if (plt_static_chain)
10327             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10328           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10329         }
10330     }
10331   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10332     {
10333       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10334       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10335       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10336     }
10337   else
10338     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10339   return p;
10340 }
10341
10342 /* Build a special .plt call stub for __tls_get_addr.  */
10343
10344 #define LD_R11_0R3      0xe9630000
10345 #define LD_R12_0R3      0xe9830000
10346 #define MR_R0_R3        0x7c601b78
10347 #define CMPDI_R11_0     0x2c2b0000
10348 #define ADD_R3_R12_R13  0x7c6c6a14
10349 #define BEQLR           0x4d820020
10350 #define MR_R3_R0        0x7c030378
10351 #define STD_R11_0R1     0xf9610000
10352 #define BCTRL           0x4e800421
10353 #define LD_R11_0R1      0xe9610000
10354 #define MTLR_R11        0x7d6803a6
10355
10356 static inline bfd_byte *
10357 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10358                          struct ppc_stub_hash_entry *stub_entry,
10359                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10360 {
10361   bfd *obfd = htab->params->stub_bfd;
10362
10363   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10364   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10365   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10366   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10367   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10368   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10369   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10370   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10371   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10372
10373   if (r != NULL)
10374     r[0].r_offset += 9 * 4;
10375   p = build_plt_stub (htab, stub_entry, p, offset, r);
10376   bfd_put_32 (obfd, BCTRL, p - 4);
10377
10378   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10379   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10380   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10381   bfd_put_32 (obfd, BLR, p),                    p += 4;
10382
10383   return p;
10384 }
10385
10386 static Elf_Internal_Rela *
10387 get_relocs (asection *sec, int count)
10388 {
10389   Elf_Internal_Rela *relocs;
10390   struct bfd_elf_section_data *elfsec_data;
10391
10392   elfsec_data = elf_section_data (sec);
10393   relocs = elfsec_data->relocs;
10394   if (relocs == NULL)
10395     {
10396       bfd_size_type relsize;
10397       relsize = sec->reloc_count * sizeof (*relocs);
10398       relocs = bfd_alloc (sec->owner, relsize);
10399       if (relocs == NULL)
10400         return NULL;
10401       elfsec_data->relocs = relocs;
10402       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10403                                           sizeof (Elf_Internal_Shdr));
10404       if (elfsec_data->rela.hdr == NULL)
10405         return NULL;
10406       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10407                                         * sizeof (Elf64_External_Rela));
10408       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10409       sec->reloc_count = 0;
10410     }
10411   relocs += sec->reloc_count;
10412   sec->reloc_count += count;
10413   return relocs;
10414 }
10415
10416 static bfd_vma
10417 get_r2off (struct bfd_link_info *info,
10418            struct ppc_stub_hash_entry *stub_entry)
10419 {
10420   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10421   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10422
10423   if (r2off == 0)
10424     {
10425       /* Support linking -R objects.  Get the toc pointer from the
10426          opd entry.  */
10427       char buf[8];
10428       if (!htab->opd_abi)
10429         return r2off;
10430       asection *opd = stub_entry->h->elf.root.u.def.section;
10431       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10432
10433       if (strcmp (opd->name, ".opd") != 0
10434           || opd->reloc_count != 0)
10435         {
10436           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10437                                   stub_entry->h->elf.root.root.string);
10438           bfd_set_error (bfd_error_bad_value);
10439           return 0;
10440         }
10441       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10442         return 0;
10443       r2off = bfd_get_64 (opd->owner, buf);
10444       r2off -= elf_gp (info->output_bfd);
10445     }
10446   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10447   return r2off;
10448 }
10449
10450 static bfd_boolean
10451 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10452 {
10453   struct ppc_stub_hash_entry *stub_entry;
10454   struct ppc_branch_hash_entry *br_entry;
10455   struct bfd_link_info *info;
10456   struct ppc_link_hash_table *htab;
10457   bfd_byte *loc;
10458   bfd_byte *p;
10459   bfd_vma dest, off;
10460   int size;
10461   Elf_Internal_Rela *r;
10462   asection *plt;
10463
10464   /* Massage our args to the form they really have.  */
10465   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10466   info = in_arg;
10467
10468   htab = ppc_hash_table (info);
10469   if (htab == NULL)
10470     return FALSE;
10471
10472   /* Make a note of the offset within the stubs for this entry.  */
10473   stub_entry->stub_offset = stub_entry->stub_sec->size;
10474   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10475
10476   htab->stub_count[stub_entry->stub_type - 1] += 1;
10477   switch (stub_entry->stub_type)
10478     {
10479     case ppc_stub_long_branch:
10480     case ppc_stub_long_branch_r2off:
10481       /* Branches are relative.  This is where we are going to.  */
10482       dest = (stub_entry->target_value
10483               + stub_entry->target_section->output_offset
10484               + stub_entry->target_section->output_section->vma);
10485       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10486       off = dest;
10487
10488       /* And this is where we are coming from.  */
10489       off -= (stub_entry->stub_offset
10490               + stub_entry->stub_sec->output_offset
10491               + stub_entry->stub_sec->output_section->vma);
10492
10493       size = 4;
10494       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10495         {
10496           bfd_vma r2off = get_r2off (info, stub_entry);
10497
10498           if (r2off == 0)
10499             {
10500               htab->stub_error = TRUE;
10501               return FALSE;
10502             }
10503           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10504           loc += 4;
10505           size = 12;
10506           if (PPC_HA (r2off) != 0)
10507             {
10508               size = 16;
10509               bfd_put_32 (htab->params->stub_bfd,
10510                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10511               loc += 4;
10512             }
10513           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10514           loc += 4;
10515           off -= size - 4;
10516         }
10517       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10518
10519       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10520         {
10521           info->callbacks->einfo
10522             (_("%P: long branch stub `%s' offset overflow\n"),
10523              stub_entry->root.string);
10524           htab->stub_error = TRUE;
10525           return FALSE;
10526         }
10527
10528       if (info->emitrelocations)
10529         {
10530           r = get_relocs (stub_entry->stub_sec, 1);
10531           if (r == NULL)
10532             return FALSE;
10533           r->r_offset = loc - stub_entry->stub_sec->contents;
10534           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10535           r->r_addend = dest;
10536           if (stub_entry->h != NULL)
10537             {
10538               struct elf_link_hash_entry **hashes;
10539               unsigned long symndx;
10540               struct ppc_link_hash_entry *h;
10541
10542               hashes = elf_sym_hashes (htab->params->stub_bfd);
10543               if (hashes == NULL)
10544                 {
10545                   bfd_size_type hsize;
10546
10547                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10548                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10549                   if (hashes == NULL)
10550                     return FALSE;
10551                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10552                   htab->stub_globals = 1;
10553                 }
10554               symndx = htab->stub_globals++;
10555               h = stub_entry->h;
10556               hashes[symndx] = &h->elf;
10557               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10558               if (h->oh != NULL && h->oh->is_func)
10559                 h = ppc_follow_link (h->oh);
10560               if (h->elf.root.u.def.section != stub_entry->target_section)
10561                 /* H is an opd symbol.  The addend must be zero.  */
10562                 r->r_addend = 0;
10563               else
10564                 {
10565                   off = (h->elf.root.u.def.value
10566                          + h->elf.root.u.def.section->output_offset
10567                          + h->elf.root.u.def.section->output_section->vma);
10568                   r->r_addend -= off;
10569                 }
10570             }
10571         }
10572       break;
10573
10574     case ppc_stub_plt_branch:
10575     case ppc_stub_plt_branch_r2off:
10576       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10577                                          stub_entry->root.string + 9,
10578                                          FALSE, FALSE);
10579       if (br_entry == NULL)
10580         {
10581           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10582                                   stub_entry->root.string);
10583           htab->stub_error = TRUE;
10584           return FALSE;
10585         }
10586
10587       dest = (stub_entry->target_value
10588               + stub_entry->target_section->output_offset
10589               + stub_entry->target_section->output_section->vma);
10590       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10591         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10592
10593       bfd_put_64 (htab->brlt->owner, dest,
10594                   htab->brlt->contents + br_entry->offset);
10595
10596       if (br_entry->iter == htab->stub_iteration)
10597         {
10598           br_entry->iter = 0;
10599
10600           if (htab->relbrlt != NULL)
10601             {
10602               /* Create a reloc for the branch lookup table entry.  */
10603               Elf_Internal_Rela rela;
10604               bfd_byte *rl;
10605
10606               rela.r_offset = (br_entry->offset
10607                                + htab->brlt->output_offset
10608                                + htab->brlt->output_section->vma);
10609               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10610               rela.r_addend = dest;
10611
10612               rl = htab->relbrlt->contents;
10613               rl += (htab->relbrlt->reloc_count++
10614                      * sizeof (Elf64_External_Rela));
10615               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10616             }
10617           else if (info->emitrelocations)
10618             {
10619               r = get_relocs (htab->brlt, 1);
10620               if (r == NULL)
10621                 return FALSE;
10622               /* brlt, being SEC_LINKER_CREATED does not go through the
10623                  normal reloc processing.  Symbols and offsets are not
10624                  translated from input file to output file form, so
10625                  set up the offset per the output file.  */
10626               r->r_offset = (br_entry->offset
10627                              + htab->brlt->output_offset
10628                              + htab->brlt->output_section->vma);
10629               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10630               r->r_addend = dest;
10631             }
10632         }
10633
10634       dest = (br_entry->offset
10635               + htab->brlt->output_offset
10636               + htab->brlt->output_section->vma);
10637
10638       off = (dest
10639              - elf_gp (htab->brlt->output_section->owner)
10640              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10641
10642       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10643         {
10644           info->callbacks->einfo
10645             (_("%P: linkage table error against `%T'\n"),
10646              stub_entry->root.string);
10647           bfd_set_error (bfd_error_bad_value);
10648           htab->stub_error = TRUE;
10649           return FALSE;
10650         }
10651
10652       if (info->emitrelocations)
10653         {
10654           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10655           if (r == NULL)
10656             return FALSE;
10657           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10658           if (bfd_big_endian (info->output_bfd))
10659             r[0].r_offset += 2;
10660           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10661             r[0].r_offset += 4;
10662           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10663           r[0].r_addend = dest;
10664           if (PPC_HA (off) != 0)
10665             {
10666               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10667               r[1].r_offset = r[0].r_offset + 4;
10668               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10669               r[1].r_addend = r[0].r_addend;
10670             }
10671         }
10672
10673       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10674         {
10675           if (PPC_HA (off) != 0)
10676             {
10677               size = 16;
10678               bfd_put_32 (htab->params->stub_bfd,
10679                           ADDIS_R12_R2 | PPC_HA (off), loc);
10680               loc += 4;
10681               bfd_put_32 (htab->params->stub_bfd,
10682                           LD_R12_0R12 | PPC_LO (off), loc);
10683             }
10684           else
10685             {
10686               size = 12;
10687               bfd_put_32 (htab->params->stub_bfd,
10688                           LD_R12_0R2 | PPC_LO (off), loc);
10689             }
10690         }
10691       else
10692         {
10693           bfd_vma r2off = get_r2off (info, stub_entry);
10694
10695           if (r2off == 0 && htab->opd_abi)
10696             {
10697               htab->stub_error = TRUE;
10698               return FALSE;
10699             }
10700
10701           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10702           loc += 4;
10703           size = 16;
10704           if (PPC_HA (off) != 0)
10705             {
10706               size += 4;
10707               bfd_put_32 (htab->params->stub_bfd,
10708                           ADDIS_R12_R2 | PPC_HA (off), loc);
10709               loc += 4;
10710               bfd_put_32 (htab->params->stub_bfd,
10711                           LD_R12_0R12 | PPC_LO (off), loc);
10712             }
10713           else
10714             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10715
10716           if (PPC_HA (r2off) != 0)
10717             {
10718               size += 4;
10719               loc += 4;
10720               bfd_put_32 (htab->params->stub_bfd,
10721                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10722             }
10723           if (PPC_LO (r2off) != 0)
10724             {
10725               size += 4;
10726               loc += 4;
10727               bfd_put_32 (htab->params->stub_bfd,
10728                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10729             }
10730         }
10731       loc += 4;
10732       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10733       loc += 4;
10734       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10735       break;
10736
10737     case ppc_stub_plt_call:
10738     case ppc_stub_plt_call_r2save:
10739       if (stub_entry->h != NULL
10740           && stub_entry->h->is_func_descriptor
10741           && stub_entry->h->oh != NULL)
10742         {
10743           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10744
10745           /* If the old-ABI "dot-symbol" is undefined make it weak so
10746              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10747              FIXME: We used to define the symbol on one of the call
10748              stubs instead, which is why we test symbol section id
10749              against htab->top_id in various places.  Likely all
10750              these checks could now disappear.  */
10751           if (fh->elf.root.type == bfd_link_hash_undefined)
10752             fh->elf.root.type = bfd_link_hash_undefweak;
10753           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10754           fh->was_undefined = 0;
10755         }
10756
10757       /* Now build the stub.  */
10758       dest = stub_entry->plt_ent->plt.offset & ~1;
10759       if (dest >= (bfd_vma) -2)
10760         abort ();
10761
10762       plt = htab->elf.splt;
10763       if (!htab->elf.dynamic_sections_created
10764           || stub_entry->h == NULL
10765           || stub_entry->h->elf.dynindx == -1)
10766         plt = htab->elf.iplt;
10767
10768       dest += plt->output_offset + plt->output_section->vma;
10769
10770       if (stub_entry->h == NULL
10771           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10772         {
10773           Elf_Internal_Rela rela;
10774           bfd_byte *rl;
10775
10776           rela.r_offset = dest;
10777           if (htab->opd_abi)
10778             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10779           else
10780             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10781           rela.r_addend = (stub_entry->target_value
10782                            + stub_entry->target_section->output_offset
10783                            + stub_entry->target_section->output_section->vma);
10784
10785           rl = (htab->elf.irelplt->contents
10786                 + (htab->elf.irelplt->reloc_count++
10787                    * sizeof (Elf64_External_Rela)));
10788           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10789           stub_entry->plt_ent->plt.offset |= 1;
10790         }
10791
10792       off = (dest
10793              - elf_gp (plt->output_section->owner)
10794              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10795
10796       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10797         {
10798           info->callbacks->einfo
10799             (_("%P: linkage table error against `%T'\n"),
10800              stub_entry->h != NULL
10801              ? stub_entry->h->elf.root.root.string
10802              : "<local sym>");
10803           bfd_set_error (bfd_error_bad_value);
10804           htab->stub_error = TRUE;
10805           return FALSE;
10806         }
10807
10808       if (htab->params->plt_stub_align != 0)
10809         {
10810           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10811
10812           stub_entry->stub_sec->size += pad;
10813           stub_entry->stub_offset = stub_entry->stub_sec->size;
10814           loc += pad;
10815         }
10816
10817       r = NULL;
10818       if (info->emitrelocations)
10819         {
10820           r = get_relocs (stub_entry->stub_sec,
10821                           ((PPC_HA (off) != 0)
10822                            + (htab->opd_abi
10823                               ? 2 + (htab->params->plt_static_chain
10824                                      && PPC_HA (off + 16) == PPC_HA (off))
10825                               : 1)));
10826           if (r == NULL)
10827             return FALSE;
10828           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10829           if (bfd_big_endian (info->output_bfd))
10830             r[0].r_offset += 2;
10831           r[0].r_addend = dest;
10832         }
10833       if (stub_entry->h != NULL
10834           && (stub_entry->h == htab->tls_get_addr_fd
10835               || stub_entry->h == htab->tls_get_addr)
10836           && !htab->params->no_tls_get_addr_opt)
10837         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10838       else
10839         p = build_plt_stub (htab, stub_entry, loc, off, r);
10840       size = p - loc;
10841       break;
10842
10843     default:
10844       BFD_FAIL ();
10845       return FALSE;
10846     }
10847
10848   stub_entry->stub_sec->size += size;
10849
10850   if (htab->params->emit_stub_syms)
10851     {
10852       struct elf_link_hash_entry *h;
10853       size_t len1, len2;
10854       char *name;
10855       const char *const stub_str[] = { "long_branch",
10856                                        "long_branch_r2off",
10857                                        "plt_branch",
10858                                        "plt_branch_r2off",
10859                                        "plt_call",
10860                                        "plt_call" };
10861
10862       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10863       len2 = strlen (stub_entry->root.string);
10864       name = bfd_malloc (len1 + len2 + 2);
10865       if (name == NULL)
10866         return FALSE;
10867       memcpy (name, stub_entry->root.string, 9);
10868       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10869       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10870       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10871       if (h == NULL)
10872         return FALSE;
10873       if (h->root.type == bfd_link_hash_new)
10874         {
10875           h->root.type = bfd_link_hash_defined;
10876           h->root.u.def.section = stub_entry->stub_sec;
10877           h->root.u.def.value = stub_entry->stub_offset;
10878           h->ref_regular = 1;
10879           h->def_regular = 1;
10880           h->ref_regular_nonweak = 1;
10881           h->forced_local = 1;
10882           h->non_elf = 0;
10883         }
10884     }
10885
10886   return TRUE;
10887 }
10888
10889 /* As above, but don't actually build the stub.  Just bump offset so
10890    we know stub section sizes, and select plt_branch stubs where
10891    long_branch stubs won't do.  */
10892
10893 static bfd_boolean
10894 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10895 {
10896   struct ppc_stub_hash_entry *stub_entry;
10897   struct bfd_link_info *info;
10898   struct ppc_link_hash_table *htab;
10899   bfd_vma off;
10900   int size;
10901
10902   /* Massage our args to the form they really have.  */
10903   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10904   info = in_arg;
10905
10906   htab = ppc_hash_table (info);
10907   if (htab == NULL)
10908     return FALSE;
10909
10910   if (stub_entry->stub_type == ppc_stub_plt_call
10911       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10912     {
10913       asection *plt;
10914       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10915       if (off >= (bfd_vma) -2)
10916         abort ();
10917       plt = htab->elf.splt;
10918       if (!htab->elf.dynamic_sections_created
10919           || stub_entry->h == NULL
10920           || stub_entry->h->elf.dynindx == -1)
10921         plt = htab->elf.iplt;
10922       off += (plt->output_offset
10923               + plt->output_section->vma
10924               - elf_gp (plt->output_section->owner)
10925               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10926
10927       size = plt_stub_size (htab, stub_entry, off);
10928       if (htab->params->plt_stub_align)
10929         size += plt_stub_pad (htab, stub_entry, off);
10930       if (info->emitrelocations)
10931         {
10932           stub_entry->stub_sec->reloc_count
10933             += ((PPC_HA (off) != 0)
10934                 + (htab->opd_abi
10935                    ? 2 + (htab->params->plt_static_chain
10936                           && PPC_HA (off + 16) == PPC_HA (off))
10937                    : 1));
10938           stub_entry->stub_sec->flags |= SEC_RELOC;
10939         }
10940     }
10941   else
10942     {
10943       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10944          variants.  */
10945       bfd_vma r2off = 0;
10946       bfd_vma local_off = 0;
10947
10948       off = (stub_entry->target_value
10949              + stub_entry->target_section->output_offset
10950              + stub_entry->target_section->output_section->vma);
10951       off -= (stub_entry->stub_sec->size
10952               + stub_entry->stub_sec->output_offset
10953               + stub_entry->stub_sec->output_section->vma);
10954
10955       /* Reset the stub type from the plt variant in case we now
10956          can reach with a shorter stub.  */
10957       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10958         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10959
10960       size = 4;
10961       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10962         {
10963           r2off = get_r2off (info, stub_entry);
10964           if (r2off == 0 && htab->opd_abi)
10965             {
10966               htab->stub_error = TRUE;
10967               return FALSE;
10968             }
10969           size = 12;
10970           if (PPC_HA (r2off) != 0)
10971             size = 16;
10972           off -= size - 4;
10973         }
10974
10975       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10976
10977       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10978          Do the same for -R objects without function descriptors.  */
10979       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10980           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10981               && r2off == 0))
10982         {
10983           struct ppc_branch_hash_entry *br_entry;
10984
10985           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10986                                              stub_entry->root.string + 9,
10987                                              TRUE, FALSE);
10988           if (br_entry == NULL)
10989             {
10990               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10991                                       stub_entry->root.string);
10992               htab->stub_error = TRUE;
10993               return FALSE;
10994             }
10995
10996           if (br_entry->iter != htab->stub_iteration)
10997             {
10998               br_entry->iter = htab->stub_iteration;
10999               br_entry->offset = htab->brlt->size;
11000               htab->brlt->size += 8;
11001
11002               if (htab->relbrlt != NULL)
11003                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11004               else if (info->emitrelocations)
11005                 {
11006                   htab->brlt->reloc_count += 1;
11007                   htab->brlt->flags |= SEC_RELOC;
11008                 }
11009             }
11010
11011           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11012           off = (br_entry->offset
11013                  + htab->brlt->output_offset
11014                  + htab->brlt->output_section->vma
11015                  - elf_gp (htab->brlt->output_section->owner)
11016                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11017
11018           if (info->emitrelocations)
11019             {
11020               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11021               stub_entry->stub_sec->flags |= SEC_RELOC;
11022             }
11023
11024           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11025             {
11026               size = 12;
11027               if (PPC_HA (off) != 0)
11028                 size = 16;
11029             }
11030           else
11031             {
11032               size = 16;
11033               if (PPC_HA (off) != 0)
11034                 size += 4;
11035
11036               if (PPC_HA (r2off) != 0)
11037                 size += 4;
11038               if (PPC_LO (r2off) != 0)
11039                 size += 4;
11040             }
11041         }
11042       else if (info->emitrelocations)
11043         {
11044           stub_entry->stub_sec->reloc_count += 1;
11045           stub_entry->stub_sec->flags |= SEC_RELOC;
11046         }
11047     }
11048
11049   stub_entry->stub_sec->size += size;
11050   return TRUE;
11051 }
11052
11053 /* Set up various things so that we can make a list of input sections
11054    for each output section included in the link.  Returns -1 on error,
11055    0 when no stubs will be needed, and 1 on success.  */
11056
11057 int
11058 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11059 {
11060   bfd *input_bfd;
11061   int top_id, top_index, id;
11062   asection *section;
11063   asection **input_list;
11064   bfd_size_type amt;
11065   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11066
11067   if (htab == NULL)
11068     return -1;
11069
11070   /* Find the top input section id.  */
11071   for (input_bfd = info->input_bfds, top_id = 3;
11072        input_bfd != NULL;
11073        input_bfd = input_bfd->link.next)
11074     {
11075       for (section = input_bfd->sections;
11076            section != NULL;
11077            section = section->next)
11078         {
11079           if (top_id < section->id)
11080             top_id = section->id;
11081         }
11082     }
11083
11084   htab->top_id = top_id;
11085   amt = sizeof (struct map_stub) * (top_id + 1);
11086   htab->stub_group = bfd_zmalloc (amt);
11087   if (htab->stub_group == NULL)
11088     return -1;
11089
11090   /* Set toc_off for com, und, abs and ind sections.  */
11091   for (id = 0; id < 3; id++)
11092     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11093
11094   /* We can't use output_bfd->section_count here to find the top output
11095      section index as some sections may have been removed, and
11096      strip_excluded_output_sections doesn't renumber the indices.  */
11097   for (section = info->output_bfd->sections, top_index = 0;
11098        section != NULL;
11099        section = section->next)
11100     {
11101       if (top_index < section->index)
11102         top_index = section->index;
11103     }
11104
11105   htab->top_index = top_index;
11106   amt = sizeof (asection *) * (top_index + 1);
11107   input_list = bfd_zmalloc (amt);
11108   htab->input_list = input_list;
11109   if (input_list == NULL)
11110     return -1;
11111
11112   return 1;
11113 }
11114
11115 /* Set up for first pass at multitoc partitioning.  */
11116
11117 void
11118 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11119 {
11120   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11121
11122   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11123   htab->toc_bfd = NULL;
11124   htab->toc_first_sec = NULL;
11125 }
11126
11127 /* The linker repeatedly calls this function for each TOC input section
11128    and linker generated GOT section.  Group input bfds such that the toc
11129    within a group is less than 64k in size.  */
11130
11131 bfd_boolean
11132 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11133 {
11134   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11135   bfd_vma addr, off, limit;
11136
11137   if (htab == NULL)
11138     return FALSE;
11139
11140   if (!htab->second_toc_pass)
11141     {
11142       /* Keep track of the first .toc or .got section for this input bfd.  */
11143       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11144
11145       if (new_bfd)
11146         {
11147           htab->toc_bfd = isec->owner;
11148           htab->toc_first_sec = isec;
11149         }
11150
11151       addr = isec->output_offset + isec->output_section->vma;
11152       off = addr - htab->toc_curr;
11153       limit = 0x80008000;
11154       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11155         limit = 0x10000;
11156       if (off + isec->size > limit)
11157         {
11158           addr = (htab->toc_first_sec->output_offset
11159                   + htab->toc_first_sec->output_section->vma);
11160           htab->toc_curr = addr;
11161         }
11162
11163       /* toc_curr is the base address of this toc group.  Set elf_gp
11164          for the input section to be the offset relative to the
11165          output toc base plus 0x8000.  Making the input elf_gp an
11166          offset allows us to move the toc as a whole without
11167          recalculating input elf_gp.  */
11168       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11169       off += TOC_BASE_OFF;
11170
11171       /* Die if someone uses a linker script that doesn't keep input
11172          file .toc and .got together.  */
11173       if (new_bfd
11174           && elf_gp (isec->owner) != 0
11175           && elf_gp (isec->owner) != off)
11176         return FALSE;
11177
11178       elf_gp (isec->owner) = off;
11179       return TRUE;
11180     }
11181
11182   /* During the second pass toc_first_sec points to the start of
11183      a toc group, and toc_curr is used to track the old elf_gp.
11184      We use toc_bfd to ensure we only look at each bfd once.  */
11185   if (htab->toc_bfd == isec->owner)
11186     return TRUE;
11187   htab->toc_bfd = isec->owner;
11188
11189   if (htab->toc_first_sec == NULL
11190       || htab->toc_curr != elf_gp (isec->owner))
11191     {
11192       htab->toc_curr = elf_gp (isec->owner);
11193       htab->toc_first_sec = isec;
11194     }
11195   addr = (htab->toc_first_sec->output_offset
11196           + htab->toc_first_sec->output_section->vma);
11197   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11198   elf_gp (isec->owner) = off;
11199
11200   return TRUE;
11201 }
11202
11203 /* Called via elf_link_hash_traverse to merge GOT entries for global
11204    symbol H.  */
11205
11206 static bfd_boolean
11207 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11208 {
11209   if (h->root.type == bfd_link_hash_indirect)
11210     return TRUE;
11211
11212   merge_got_entries (&h->got.glist);
11213
11214   return TRUE;
11215 }
11216
11217 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11218    symbol H.  */
11219
11220 static bfd_boolean
11221 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11222 {
11223   struct got_entry *gent;
11224
11225   if (h->root.type == bfd_link_hash_indirect)
11226     return TRUE;
11227
11228   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11229     if (!gent->is_indirect)
11230       allocate_got (h, (struct bfd_link_info *) inf, gent);
11231   return TRUE;
11232 }
11233
11234 /* Called on the first multitoc pass after the last call to
11235    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11236    entries.  */
11237
11238 bfd_boolean
11239 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11240 {
11241   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11242   struct bfd *ibfd, *ibfd2;
11243   bfd_boolean done_something;
11244
11245   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11246
11247   if (!htab->do_multi_toc)
11248     return FALSE;
11249
11250   /* Merge global sym got entries within a toc group.  */
11251   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11252
11253   /* And tlsld_got.  */
11254   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11255     {
11256       struct got_entry *ent, *ent2;
11257
11258       if (!is_ppc64_elf (ibfd))
11259         continue;
11260
11261       ent = ppc64_tlsld_got (ibfd);
11262       if (!ent->is_indirect
11263           && ent->got.offset != (bfd_vma) -1)
11264         {
11265           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11266             {
11267               if (!is_ppc64_elf (ibfd2))
11268                 continue;
11269
11270               ent2 = ppc64_tlsld_got (ibfd2);
11271               if (!ent2->is_indirect
11272                   && ent2->got.offset != (bfd_vma) -1
11273                   && elf_gp (ibfd2) == elf_gp (ibfd))
11274                 {
11275                   ent2->is_indirect = TRUE;
11276                   ent2->got.ent = ent;
11277                 }
11278             }
11279         }
11280     }
11281
11282   /* Zap sizes of got sections.  */
11283   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11284   htab->elf.irelplt->size -= htab->got_reli_size;
11285   htab->got_reli_size = 0;
11286
11287   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11288     {
11289       asection *got, *relgot;
11290
11291       if (!is_ppc64_elf (ibfd))
11292         continue;
11293
11294       got = ppc64_elf_tdata (ibfd)->got;
11295       if (got != NULL)
11296         {
11297           got->rawsize = got->size;
11298           got->size = 0;
11299           relgot = ppc64_elf_tdata (ibfd)->relgot;
11300           relgot->rawsize = relgot->size;
11301           relgot->size = 0;
11302         }
11303     }
11304
11305   /* Now reallocate the got, local syms first.  We don't need to
11306      allocate section contents again since we never increase size.  */
11307   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11308     {
11309       struct got_entry **lgot_ents;
11310       struct got_entry **end_lgot_ents;
11311       struct plt_entry **local_plt;
11312       struct plt_entry **end_local_plt;
11313       unsigned char *lgot_masks;
11314       bfd_size_type locsymcount;
11315       Elf_Internal_Shdr *symtab_hdr;
11316       asection *s;
11317
11318       if (!is_ppc64_elf (ibfd))
11319         continue;
11320
11321       lgot_ents = elf_local_got_ents (ibfd);
11322       if (!lgot_ents)
11323         continue;
11324
11325       symtab_hdr = &elf_symtab_hdr (ibfd);
11326       locsymcount = symtab_hdr->sh_info;
11327       end_lgot_ents = lgot_ents + locsymcount;
11328       local_plt = (struct plt_entry **) end_lgot_ents;
11329       end_local_plt = local_plt + locsymcount;
11330       lgot_masks = (unsigned char *) end_local_plt;
11331       s = ppc64_elf_tdata (ibfd)->got;
11332       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11333         {
11334           struct got_entry *ent;
11335
11336           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11337             {
11338               unsigned int ent_size = 8;
11339               unsigned int rel_size = sizeof (Elf64_External_Rela);
11340
11341               ent->got.offset = s->size;
11342               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11343                 {
11344                   ent_size *= 2;
11345                   rel_size *= 2;
11346                 }
11347               s->size += ent_size;
11348               if ((*lgot_masks & PLT_IFUNC) != 0)
11349                 {
11350                   htab->elf.irelplt->size += rel_size;
11351                   htab->got_reli_size += rel_size;
11352                 }
11353               else if (info->shared)
11354                 {
11355                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11356                   srel->size += rel_size;
11357                 }
11358             }
11359         }
11360     }
11361
11362   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11363
11364   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11365     {
11366       struct got_entry *ent;
11367
11368       if (!is_ppc64_elf (ibfd))
11369         continue;
11370
11371       ent = ppc64_tlsld_got (ibfd);
11372       if (!ent->is_indirect
11373           && ent->got.offset != (bfd_vma) -1)
11374         {
11375           asection *s = ppc64_elf_tdata (ibfd)->got;
11376           ent->got.offset = s->size;
11377           s->size += 16;
11378           if (info->shared)
11379             {
11380               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11381               srel->size += sizeof (Elf64_External_Rela);
11382             }
11383         }
11384     }
11385
11386   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11387   if (!done_something)
11388     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11389       {
11390         asection *got;
11391
11392         if (!is_ppc64_elf (ibfd))
11393           continue;
11394
11395         got = ppc64_elf_tdata (ibfd)->got;
11396         if (got != NULL)
11397           {
11398             done_something = got->rawsize != got->size;
11399             if (done_something)
11400               break;
11401           }
11402       }
11403
11404   if (done_something)
11405     (*htab->params->layout_sections_again) ();
11406
11407   /* Set up for second pass over toc sections to recalculate elf_gp
11408      on input sections.  */
11409   htab->toc_bfd = NULL;
11410   htab->toc_first_sec = NULL;
11411   htab->second_toc_pass = TRUE;
11412   return done_something;
11413 }
11414
11415 /* Called after second pass of multitoc partitioning.  */
11416
11417 void
11418 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11419 {
11420   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11421
11422   /* After the second pass, toc_curr tracks the TOC offset used
11423      for code sections below in ppc64_elf_next_input_section.  */
11424   htab->toc_curr = TOC_BASE_OFF;
11425 }
11426
11427 /* No toc references were found in ISEC.  If the code in ISEC makes no
11428    calls, then there's no need to use toc adjusting stubs when branching
11429    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11430    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11431    needed, and 2 if a cyclical call-graph was found but no other reason
11432    for a stub was detected.  If called from the top level, a return of
11433    2 means the same as a return of 0.  */
11434
11435 static int
11436 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11437 {
11438   int ret;
11439
11440   /* Mark this section as checked.  */
11441   isec->call_check_done = 1;
11442
11443   /* We know none of our code bearing sections will need toc stubs.  */
11444   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11445     return 0;
11446
11447   if (isec->size == 0)
11448     return 0;
11449
11450   if (isec->output_section == NULL)
11451     return 0;
11452
11453   ret = 0;
11454   if (isec->reloc_count != 0)
11455     {
11456       Elf_Internal_Rela *relstart, *rel;
11457       Elf_Internal_Sym *local_syms;
11458       struct ppc_link_hash_table *htab;
11459
11460       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11461                                             info->keep_memory);
11462       if (relstart == NULL)
11463         return -1;
11464
11465       /* Look for branches to outside of this section.  */
11466       local_syms = NULL;
11467       htab = ppc_hash_table (info);
11468       if (htab == NULL)
11469         return -1;
11470
11471       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11472         {
11473           enum elf_ppc64_reloc_type r_type;
11474           unsigned long r_symndx;
11475           struct elf_link_hash_entry *h;
11476           struct ppc_link_hash_entry *eh;
11477           Elf_Internal_Sym *sym;
11478           asection *sym_sec;
11479           struct _opd_sec_data *opd;
11480           bfd_vma sym_value;
11481           bfd_vma dest;
11482
11483           r_type = ELF64_R_TYPE (rel->r_info);
11484           if (r_type != R_PPC64_REL24
11485               && r_type != R_PPC64_REL14
11486               && r_type != R_PPC64_REL14_BRTAKEN
11487               && r_type != R_PPC64_REL14_BRNTAKEN)
11488             continue;
11489
11490           r_symndx = ELF64_R_SYM (rel->r_info);
11491           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11492                           isec->owner))
11493             {
11494               ret = -1;
11495               break;
11496             }
11497
11498           /* Calls to dynamic lib functions go through a plt call stub
11499              that uses r2.  */
11500           eh = (struct ppc_link_hash_entry *) h;
11501           if (eh != NULL
11502               && (eh->elf.plt.plist != NULL
11503                   || (eh->oh != NULL
11504                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11505             {
11506               ret = 1;
11507               break;
11508             }
11509
11510           if (sym_sec == NULL)
11511             /* Ignore other undefined symbols.  */
11512             continue;
11513
11514           /* Assume branches to other sections not included in the
11515              link need stubs too, to cover -R and absolute syms.  */
11516           if (sym_sec->output_section == NULL)
11517             {
11518               ret = 1;
11519               break;
11520             }
11521
11522           if (h == NULL)
11523             sym_value = sym->st_value;
11524           else
11525             {
11526               if (h->root.type != bfd_link_hash_defined
11527                   && h->root.type != bfd_link_hash_defweak)
11528                 abort ();
11529               sym_value = h->root.u.def.value;
11530             }
11531           sym_value += rel->r_addend;
11532
11533           /* If this branch reloc uses an opd sym, find the code section.  */
11534           opd = get_opd_info (sym_sec);
11535           if (opd != NULL)
11536             {
11537               if (h == NULL && opd->adjust != NULL)
11538                 {
11539                   long adjust;
11540
11541                   adjust = opd->adjust[sym->st_value / 8];
11542                   if (adjust == -1)
11543                     /* Assume deleted functions won't ever be called.  */
11544                     continue;
11545                   sym_value += adjust;
11546                 }
11547
11548               dest = opd_entry_value (sym_sec, sym_value,
11549                                       &sym_sec, NULL, FALSE);
11550               if (dest == (bfd_vma) -1)
11551                 continue;
11552             }
11553           else
11554             dest = (sym_value
11555                     + sym_sec->output_offset
11556                     + sym_sec->output_section->vma);
11557
11558           /* Ignore branch to self.  */
11559           if (sym_sec == isec)
11560             continue;
11561
11562           /* If the called function uses the toc, we need a stub.  */
11563           if (sym_sec->has_toc_reloc
11564               || sym_sec->makes_toc_func_call)
11565             {
11566               ret = 1;
11567               break;
11568             }
11569
11570           /* Assume any branch that needs a long branch stub might in fact
11571              need a plt_branch stub.  A plt_branch stub uses r2.  */
11572           else if (dest - (isec->output_offset
11573                            + isec->output_section->vma
11574                            + rel->r_offset) + (1 << 25)
11575                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11576                                                              ? h->other
11577                                                              : sym->st_other))
11578             {
11579               ret = 1;
11580               break;
11581             }
11582
11583           /* If calling back to a section in the process of being
11584              tested, we can't say for sure that no toc adjusting stubs
11585              are needed, so don't return zero.  */
11586           else if (sym_sec->call_check_in_progress)
11587             ret = 2;
11588
11589           /* Branches to another section that itself doesn't have any TOC
11590              references are OK.  Recursively call ourselves to check.  */
11591           else if (!sym_sec->call_check_done)
11592             {
11593               int recur;
11594
11595               /* Mark current section as indeterminate, so that other
11596                  sections that call back to current won't be marked as
11597                  known.  */
11598               isec->call_check_in_progress = 1;
11599               recur = toc_adjusting_stub_needed (info, sym_sec);
11600               isec->call_check_in_progress = 0;
11601
11602               if (recur != 0)
11603                 {
11604                   ret = recur;
11605                   if (recur != 2)
11606                     break;
11607                 }
11608             }
11609         }
11610
11611       if (local_syms != NULL
11612           && (elf_symtab_hdr (isec->owner).contents
11613               != (unsigned char *) local_syms))
11614         free (local_syms);
11615       if (elf_section_data (isec)->relocs != relstart)
11616         free (relstart);
11617     }
11618
11619   if ((ret & 1) == 0
11620       && isec->map_head.s != NULL
11621       && (strcmp (isec->output_section->name, ".init") == 0
11622           || strcmp (isec->output_section->name, ".fini") == 0))
11623     {
11624       if (isec->map_head.s->has_toc_reloc
11625           || isec->map_head.s->makes_toc_func_call)
11626         ret = 1;
11627       else if (!isec->map_head.s->call_check_done)
11628         {
11629           int recur;
11630           isec->call_check_in_progress = 1;
11631           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11632           isec->call_check_in_progress = 0;
11633           if (recur != 0)
11634             ret = recur;
11635         }
11636     }
11637
11638   if (ret == 1)
11639     isec->makes_toc_func_call = 1;
11640
11641   return ret;
11642 }
11643
11644 /* The linker repeatedly calls this function for each input section,
11645    in the order that input sections are linked into output sections.
11646    Build lists of input sections to determine groupings between which
11647    we may insert linker stubs.  */
11648
11649 bfd_boolean
11650 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11651 {
11652   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11653
11654   if (htab == NULL)
11655     return FALSE;
11656
11657   if ((isec->output_section->flags & SEC_CODE) != 0
11658       && isec->output_section->index <= htab->top_index)
11659     {
11660       asection **list = htab->input_list + isec->output_section->index;
11661       /* Steal the link_sec pointer for our list.  */
11662 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11663       /* This happens to make the list in reverse order,
11664          which is what we want.  */
11665       PREV_SEC (isec) = *list;
11666       *list = isec;
11667     }
11668
11669   if (htab->multi_toc_needed)
11670     {
11671       /* Analyse sections that aren't already flagged as needing a
11672          valid toc pointer.  Exclude .fixup for the linux kernel.
11673          .fixup contains branches, but only back to the function that
11674          hit an exception.  */
11675       if (!(isec->has_toc_reloc
11676             || (isec->flags & SEC_CODE) == 0
11677             || strcmp (isec->name, ".fixup") == 0
11678             || isec->call_check_done))
11679         {
11680           if (toc_adjusting_stub_needed (info, isec) < 0)
11681             return FALSE;
11682         }
11683       /* Make all sections use the TOC assigned for this object file.
11684          This will be wrong for pasted sections;  We fix that in
11685          check_pasted_section().  */
11686       if (elf_gp (isec->owner) != 0)
11687         htab->toc_curr = elf_gp (isec->owner);
11688     }
11689
11690   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11691   return TRUE;
11692 }
11693
11694 /* Check that all .init and .fini sections use the same toc, if they
11695    have toc relocs.  */
11696
11697 static bfd_boolean
11698 check_pasted_section (struct bfd_link_info *info, const char *name)
11699 {
11700   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11701
11702   if (o != NULL)
11703     {
11704       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11705       bfd_vma toc_off = 0;
11706       asection *i;
11707
11708       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11709         if (i->has_toc_reloc)
11710           {
11711             if (toc_off == 0)
11712               toc_off = htab->stub_group[i->id].toc_off;
11713             else if (toc_off != htab->stub_group[i->id].toc_off)
11714               return FALSE;
11715           }
11716
11717       if (toc_off == 0)
11718         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11719           if (i->makes_toc_func_call)
11720             {
11721               toc_off = htab->stub_group[i->id].toc_off;
11722               break;
11723             }
11724
11725       /* Make sure the whole pasted function uses the same toc offset.  */
11726       if (toc_off != 0)
11727         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11728           htab->stub_group[i->id].toc_off = toc_off;
11729     }
11730   return TRUE;
11731 }
11732
11733 bfd_boolean
11734 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11735 {
11736   return (check_pasted_section (info, ".init")
11737           & check_pasted_section (info, ".fini"));
11738 }
11739
11740 /* See whether we can group stub sections together.  Grouping stub
11741    sections may result in fewer stubs.  More importantly, we need to
11742    put all .init* and .fini* stubs at the beginning of the .init or
11743    .fini output sections respectively, because glibc splits the
11744    _init and _fini functions into multiple parts.  Putting a stub in
11745    the middle of a function is not a good idea.  */
11746
11747 static void
11748 group_sections (struct ppc_link_hash_table *htab,
11749                 bfd_size_type stub_group_size,
11750                 bfd_boolean stubs_always_before_branch)
11751 {
11752   asection **list;
11753   bfd_size_type stub14_group_size;
11754   bfd_boolean suppress_size_errors;
11755
11756   suppress_size_errors = FALSE;
11757   stub14_group_size = stub_group_size;
11758   if (stub_group_size == 1)
11759     {
11760       /* Default values.  */
11761       if (stubs_always_before_branch)
11762         {
11763           stub_group_size = 0x1e00000;
11764           stub14_group_size = 0x7800;
11765         }
11766       else
11767         {
11768           stub_group_size = 0x1c00000;
11769           stub14_group_size = 0x7000;
11770         }
11771       suppress_size_errors = TRUE;
11772     }
11773
11774   list = htab->input_list + htab->top_index;
11775   do
11776     {
11777       asection *tail = *list;
11778       while (tail != NULL)
11779         {
11780           asection *curr;
11781           asection *prev;
11782           bfd_size_type total;
11783           bfd_boolean big_sec;
11784           bfd_vma curr_toc;
11785
11786           curr = tail;
11787           total = tail->size;
11788           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11789                              && ppc64_elf_section_data (tail)->has_14bit_branch
11790                              ? stub14_group_size : stub_group_size);
11791           if (big_sec && !suppress_size_errors)
11792             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11793                                      tail->owner, tail);
11794           curr_toc = htab->stub_group[tail->id].toc_off;
11795
11796           while ((prev = PREV_SEC (curr)) != NULL
11797                  && ((total += curr->output_offset - prev->output_offset)
11798                      < (ppc64_elf_section_data (prev) != NULL
11799                         && ppc64_elf_section_data (prev)->has_14bit_branch
11800                         ? stub14_group_size : stub_group_size))
11801                  && htab->stub_group[prev->id].toc_off == curr_toc)
11802             curr = prev;
11803
11804           /* OK, the size from the start of CURR to the end is less
11805              than stub_group_size and thus can be handled by one stub
11806              section.  (or the tail section is itself larger than
11807              stub_group_size, in which case we may be toast.)  We
11808              should really be keeping track of the total size of stubs
11809              added here, as stubs contribute to the final output
11810              section size.  That's a little tricky, and this way will
11811              only break if stubs added make the total size more than
11812              2^25, ie. for the default stub_group_size, if stubs total
11813              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11814           do
11815             {
11816               prev = PREV_SEC (tail);
11817               /* Set up this stub group.  */
11818               htab->stub_group[tail->id].link_sec = curr;
11819             }
11820           while (tail != curr && (tail = prev) != NULL);
11821
11822           /* But wait, there's more!  Input sections up to stub_group_size
11823              bytes before the stub section can be handled by it too.
11824              Don't do this if we have a really large section after the
11825              stubs, as adding more stubs increases the chance that
11826              branches may not reach into the stub section.  */
11827           if (!stubs_always_before_branch && !big_sec)
11828             {
11829               total = 0;
11830               while (prev != NULL
11831                      && ((total += tail->output_offset - prev->output_offset)
11832                          < (ppc64_elf_section_data (prev) != NULL
11833                             && ppc64_elf_section_data (prev)->has_14bit_branch
11834                             ? stub14_group_size : stub_group_size))
11835                      && htab->stub_group[prev->id].toc_off == curr_toc)
11836                 {
11837                   tail = prev;
11838                   prev = PREV_SEC (tail);
11839                   htab->stub_group[tail->id].link_sec = curr;
11840                 }
11841             }
11842           tail = prev;
11843         }
11844     }
11845   while (list-- != htab->input_list);
11846   free (htab->input_list);
11847 #undef PREV_SEC
11848 }
11849
11850 static const unsigned char glink_eh_frame_cie[] =
11851 {
11852   0, 0, 0, 16,                          /* length.  */
11853   0, 0, 0, 0,                           /* id.  */
11854   1,                                    /* CIE version.  */
11855   'z', 'R', 0,                          /* Augmentation string.  */
11856   4,                                    /* Code alignment.  */
11857   0x78,                                 /* Data alignment.  */
11858   65,                                   /* RA reg.  */
11859   1,                                    /* Augmentation size.  */
11860   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11861   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11862 };
11863
11864 /* Stripping output sections is normally done before dynamic section
11865    symbols have been allocated.  This function is called later, and
11866    handles cases like htab->brlt which is mapped to its own output
11867    section.  */
11868
11869 static void
11870 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11871 {
11872   if (isec->size == 0
11873       && isec->output_section->size == 0
11874       && !(isec->output_section->flags & SEC_KEEP)
11875       && !bfd_section_removed_from_list (info->output_bfd,
11876                                          isec->output_section)
11877       && elf_section_data (isec->output_section)->dynindx == 0)
11878     {
11879       isec->output_section->flags |= SEC_EXCLUDE;
11880       bfd_section_list_remove (info->output_bfd, isec->output_section);
11881       info->output_bfd->section_count--;
11882     }
11883 }
11884
11885 /* Determine and set the size of the stub section for a final link.
11886
11887    The basic idea here is to examine all the relocations looking for
11888    PC-relative calls to a target that is unreachable with a "bl"
11889    instruction.  */
11890
11891 bfd_boolean
11892 ppc64_elf_size_stubs (struct bfd_link_info *info)
11893 {
11894   bfd_size_type stub_group_size;
11895   bfd_boolean stubs_always_before_branch;
11896   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11897
11898   if (htab == NULL)
11899     return FALSE;
11900
11901   if (htab->params->plt_thread_safe == -1 && !info->executable)
11902     htab->params->plt_thread_safe = 1;
11903   if (!htab->opd_abi)
11904     htab->params->plt_thread_safe = 0;
11905   else if (htab->params->plt_thread_safe == -1)
11906     {
11907       static const char *const thread_starter[] =
11908         {
11909           "pthread_create",
11910           /* libstdc++ */
11911           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11912           /* librt */
11913           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11914           "mq_notify", "create_timer",
11915           /* libanl */
11916           "getaddrinfo_a",
11917           /* libgomp */
11918           "GOMP_parallel_start",
11919           "GOMP_parallel_loop_static_start",
11920           "GOMP_parallel_loop_dynamic_start",
11921           "GOMP_parallel_loop_guided_start",
11922           "GOMP_parallel_loop_runtime_start",
11923           "GOMP_parallel_sections_start",
11924         };
11925       unsigned i;
11926
11927       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11928         {
11929           struct elf_link_hash_entry *h;
11930           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11931                                     FALSE, FALSE, TRUE);
11932           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11933           if (htab->params->plt_thread_safe)
11934             break;
11935         }
11936     }
11937   stubs_always_before_branch = htab->params->group_size < 0;
11938   if (htab->params->group_size < 0)
11939     stub_group_size = -htab->params->group_size;
11940   else
11941     stub_group_size = htab->params->group_size;
11942
11943   group_sections (htab, stub_group_size, stubs_always_before_branch);
11944
11945   while (1)
11946     {
11947       bfd *input_bfd;
11948       unsigned int bfd_indx;
11949       asection *stub_sec;
11950
11951       htab->stub_iteration += 1;
11952
11953       for (input_bfd = info->input_bfds, bfd_indx = 0;
11954            input_bfd != NULL;
11955            input_bfd = input_bfd->link.next, bfd_indx++)
11956         {
11957           Elf_Internal_Shdr *symtab_hdr;
11958           asection *section;
11959           Elf_Internal_Sym *local_syms = NULL;
11960
11961           if (!is_ppc64_elf (input_bfd))
11962             continue;
11963
11964           /* We'll need the symbol table in a second.  */
11965           symtab_hdr = &elf_symtab_hdr (input_bfd);
11966           if (symtab_hdr->sh_info == 0)
11967             continue;
11968
11969           /* Walk over each section attached to the input bfd.  */
11970           for (section = input_bfd->sections;
11971                section != NULL;
11972                section = section->next)
11973             {
11974               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11975
11976               /* If there aren't any relocs, then there's nothing more
11977                  to do.  */
11978               if ((section->flags & SEC_RELOC) == 0
11979                   || (section->flags & SEC_ALLOC) == 0
11980                   || (section->flags & SEC_LOAD) == 0
11981                   || (section->flags & SEC_CODE) == 0
11982                   || section->reloc_count == 0)
11983                 continue;
11984
11985               /* If this section is a link-once section that will be
11986                  discarded, then don't create any stubs.  */
11987               if (section->output_section == NULL
11988                   || section->output_section->owner != info->output_bfd)
11989                 continue;
11990
11991               /* Get the relocs.  */
11992               internal_relocs
11993                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11994                                              info->keep_memory);
11995               if (internal_relocs == NULL)
11996                 goto error_ret_free_local;
11997
11998               /* Now examine each relocation.  */
11999               irela = internal_relocs;
12000               irelaend = irela + section->reloc_count;
12001               for (; irela < irelaend; irela++)
12002                 {
12003                   enum elf_ppc64_reloc_type r_type;
12004                   unsigned int r_indx;
12005                   enum ppc_stub_type stub_type;
12006                   struct ppc_stub_hash_entry *stub_entry;
12007                   asection *sym_sec, *code_sec;
12008                   bfd_vma sym_value, code_value;
12009                   bfd_vma destination;
12010                   unsigned long local_off;
12011                   bfd_boolean ok_dest;
12012                   struct ppc_link_hash_entry *hash;
12013                   struct ppc_link_hash_entry *fdh;
12014                   struct elf_link_hash_entry *h;
12015                   Elf_Internal_Sym *sym;
12016                   char *stub_name;
12017                   const asection *id_sec;
12018                   struct _opd_sec_data *opd;
12019                   struct plt_entry *plt_ent;
12020
12021                   r_type = ELF64_R_TYPE (irela->r_info);
12022                   r_indx = ELF64_R_SYM (irela->r_info);
12023
12024                   if (r_type >= R_PPC64_max)
12025                     {
12026                       bfd_set_error (bfd_error_bad_value);
12027                       goto error_ret_free_internal;
12028                     }
12029
12030                   /* Only look for stubs on branch instructions.  */
12031                   if (r_type != R_PPC64_REL24
12032                       && r_type != R_PPC64_REL14
12033                       && r_type != R_PPC64_REL14_BRTAKEN
12034                       && r_type != R_PPC64_REL14_BRNTAKEN)
12035                     continue;
12036
12037                   /* Now determine the call target, its name, value,
12038                      section.  */
12039                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12040                                   r_indx, input_bfd))
12041                     goto error_ret_free_internal;
12042                   hash = (struct ppc_link_hash_entry *) h;
12043
12044                   ok_dest = FALSE;
12045                   fdh = NULL;
12046                   sym_value = 0;
12047                   if (hash == NULL)
12048                     {
12049                       sym_value = sym->st_value;
12050                       ok_dest = TRUE;
12051                     }
12052                   else if (hash->elf.root.type == bfd_link_hash_defined
12053                            || hash->elf.root.type == bfd_link_hash_defweak)
12054                     {
12055                       sym_value = hash->elf.root.u.def.value;
12056                       if (sym_sec->output_section != NULL)
12057                         ok_dest = TRUE;
12058                     }
12059                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12060                            || hash->elf.root.type == bfd_link_hash_undefined)
12061                     {
12062                       /* Recognise an old ABI func code entry sym, and
12063                          use the func descriptor sym instead if it is
12064                          defined.  */
12065                       if (hash->elf.root.root.string[0] == '.'
12066                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12067                         {
12068                           if (fdh->elf.root.type == bfd_link_hash_defined
12069                               || fdh->elf.root.type == bfd_link_hash_defweak)
12070                             {
12071                               sym_sec = fdh->elf.root.u.def.section;
12072                               sym_value = fdh->elf.root.u.def.value;
12073                               if (sym_sec->output_section != NULL)
12074                                 ok_dest = TRUE;
12075                             }
12076                           else
12077                             fdh = NULL;
12078                         }
12079                     }
12080                   else
12081                     {
12082                       bfd_set_error (bfd_error_bad_value);
12083                       goto error_ret_free_internal;
12084                     }
12085
12086                   destination = 0;
12087                   local_off = 0;
12088                   if (ok_dest)
12089                     {
12090                       sym_value += irela->r_addend;
12091                       destination = (sym_value
12092                                      + sym_sec->output_offset
12093                                      + sym_sec->output_section->vma);
12094                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12095                                                             ? hash->elf.other
12096                                                             : sym->st_other);
12097                     }
12098
12099                   code_sec = sym_sec;
12100                   code_value = sym_value;
12101                   opd = get_opd_info (sym_sec);
12102                   if (opd != NULL)
12103                     {
12104                       bfd_vma dest;
12105
12106                       if (hash == NULL && opd->adjust != NULL)
12107                         {
12108                           long adjust = opd->adjust[sym_value / 8];
12109                           if (adjust == -1)
12110                             continue;
12111                           code_value += adjust;
12112                           sym_value += adjust;
12113                         }
12114                       dest = opd_entry_value (sym_sec, sym_value,
12115                                               &code_sec, &code_value, FALSE);
12116                       if (dest != (bfd_vma) -1)
12117                         {
12118                           destination = dest;
12119                           if (fdh != NULL)
12120                             {
12121                               /* Fixup old ABI sym to point at code
12122                                  entry.  */
12123                               hash->elf.root.type = bfd_link_hash_defweak;
12124                               hash->elf.root.u.def.section = code_sec;
12125                               hash->elf.root.u.def.value = code_value;
12126                             }
12127                         }
12128                     }
12129
12130                   /* Determine what (if any) linker stub is needed.  */
12131                   plt_ent = NULL;
12132                   stub_type = ppc_type_of_stub (section, irela, &hash,
12133                                                 &plt_ent, destination,
12134                                                 local_off);
12135
12136                   if (stub_type != ppc_stub_plt_call)
12137                     {
12138                       /* Check whether we need a TOC adjusting stub.
12139                          Since the linker pastes together pieces from
12140                          different object files when creating the
12141                          _init and _fini functions, it may be that a
12142                          call to what looks like a local sym is in
12143                          fact a call needing a TOC adjustment.  */
12144                       if (code_sec != NULL
12145                           && code_sec->output_section != NULL
12146                           && (htab->stub_group[code_sec->id].toc_off
12147                               != htab->stub_group[section->id].toc_off)
12148                           && (code_sec->has_toc_reloc
12149                               || code_sec->makes_toc_func_call))
12150                         stub_type = ppc_stub_long_branch_r2off;
12151                     }
12152
12153                   if (stub_type == ppc_stub_none)
12154                     continue;
12155
12156                   /* __tls_get_addr calls might be eliminated.  */
12157                   if (stub_type != ppc_stub_plt_call
12158                       && hash != NULL
12159                       && (hash == htab->tls_get_addr
12160                           || hash == htab->tls_get_addr_fd)
12161                       && section->has_tls_reloc
12162                       && irela != internal_relocs)
12163                     {
12164                       /* Get tls info.  */
12165                       unsigned char *tls_mask;
12166
12167                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12168                                          irela - 1, input_bfd))
12169                         goto error_ret_free_internal;
12170                       if (*tls_mask != 0)
12171                         continue;
12172                     }
12173
12174                   if (stub_type == ppc_stub_plt_call
12175                       && irela + 1 < irelaend
12176                       && irela[1].r_offset == irela->r_offset + 4
12177                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12178                     {
12179                       if (!tocsave_find (htab, INSERT,
12180                                          &local_syms, irela + 1, input_bfd))
12181                         goto error_ret_free_internal;
12182                     }
12183                   else if (stub_type == ppc_stub_plt_call)
12184                     stub_type = ppc_stub_plt_call_r2save;
12185
12186                   /* Support for grouping stub sections.  */
12187                   id_sec = htab->stub_group[section->id].link_sec;
12188
12189                   /* Get the name of this stub.  */
12190                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12191                   if (!stub_name)
12192                     goto error_ret_free_internal;
12193
12194                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12195                                                      stub_name, FALSE, FALSE);
12196                   if (stub_entry != NULL)
12197                     {
12198                       /* The proper stub has already been created.  */
12199                       free (stub_name);
12200                       if (stub_type == ppc_stub_plt_call_r2save)
12201                         stub_entry->stub_type = stub_type;
12202                       continue;
12203                     }
12204
12205                   stub_entry = ppc_add_stub (stub_name, section, info);
12206                   if (stub_entry == NULL)
12207                     {
12208                       free (stub_name);
12209                     error_ret_free_internal:
12210                       if (elf_section_data (section)->relocs == NULL)
12211                         free (internal_relocs);
12212                     error_ret_free_local:
12213                       if (local_syms != NULL
12214                           && (symtab_hdr->contents
12215                               != (unsigned char *) local_syms))
12216                         free (local_syms);
12217                       return FALSE;
12218                     }
12219
12220                   stub_entry->stub_type = stub_type;
12221                   if (stub_type != ppc_stub_plt_call
12222                       && stub_type != ppc_stub_plt_call_r2save)
12223                     {
12224                       stub_entry->target_value = code_value;
12225                       stub_entry->target_section = code_sec;
12226                     }
12227                   else
12228                     {
12229                       stub_entry->target_value = sym_value;
12230                       stub_entry->target_section = sym_sec;
12231                     }
12232                   stub_entry->h = hash;
12233                   stub_entry->plt_ent = plt_ent;
12234                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12235
12236                   if (stub_entry->h != NULL)
12237                     htab->stub_globals += 1;
12238                 }
12239
12240               /* We're done with the internal relocs, free them.  */
12241               if (elf_section_data (section)->relocs != internal_relocs)
12242                 free (internal_relocs);
12243             }
12244
12245           if (local_syms != NULL
12246               && symtab_hdr->contents != (unsigned char *) local_syms)
12247             {
12248               if (!info->keep_memory)
12249                 free (local_syms);
12250               else
12251                 symtab_hdr->contents = (unsigned char *) local_syms;
12252             }
12253         }
12254
12255       /* We may have added some stubs.  Find out the new size of the
12256          stub sections.  */
12257       for (stub_sec = htab->params->stub_bfd->sections;
12258            stub_sec != NULL;
12259            stub_sec = stub_sec->next)
12260         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12261           {
12262             stub_sec->rawsize = stub_sec->size;
12263             stub_sec->size = 0;
12264             stub_sec->reloc_count = 0;
12265             stub_sec->flags &= ~SEC_RELOC;
12266           }
12267
12268       htab->brlt->size = 0;
12269       htab->brlt->reloc_count = 0;
12270       htab->brlt->flags &= ~SEC_RELOC;
12271       if (htab->relbrlt != NULL)
12272         htab->relbrlt->size = 0;
12273
12274       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12275
12276       if (info->emitrelocations
12277           && htab->glink != NULL && htab->glink->size != 0)
12278         {
12279           htab->glink->reloc_count = 1;
12280           htab->glink->flags |= SEC_RELOC;
12281         }
12282
12283       if (htab->glink_eh_frame != NULL
12284           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12285           && htab->glink_eh_frame->output_section->size != 0)
12286         {
12287           size_t size = 0, align;
12288
12289           for (stub_sec = htab->params->stub_bfd->sections;
12290                stub_sec != NULL;
12291                stub_sec = stub_sec->next)
12292             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12293               size += 20;
12294           if (htab->glink != NULL && htab->glink->size != 0)
12295             size += 24;
12296           if (size != 0)
12297             size += sizeof (glink_eh_frame_cie);
12298           align = 1;
12299           align <<= htab->glink_eh_frame->output_section->alignment_power;
12300           align -= 1;
12301           size = (size + align) & ~align;
12302           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12303           htab->glink_eh_frame->size = size;
12304         }
12305
12306       if (htab->params->plt_stub_align != 0)
12307         for (stub_sec = htab->params->stub_bfd->sections;
12308              stub_sec != NULL;
12309              stub_sec = stub_sec->next)
12310           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12311             stub_sec->size = ((stub_sec->size
12312                                + (1 << htab->params->plt_stub_align) - 1)
12313                               & (-1 << htab->params->plt_stub_align));
12314
12315       for (stub_sec = htab->params->stub_bfd->sections;
12316            stub_sec != NULL;
12317            stub_sec = stub_sec->next)
12318         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12319             && stub_sec->rawsize != stub_sec->size)
12320           break;
12321
12322       /* Exit from this loop when no stubs have been added, and no stubs
12323          have changed size.  */
12324       if (stub_sec == NULL
12325           && (htab->glink_eh_frame == NULL
12326               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12327         break;
12328
12329       /* Ask the linker to do its stuff.  */
12330       (*htab->params->layout_sections_again) ();
12331     }
12332
12333   maybe_strip_output (info, htab->brlt);
12334   if (htab->glink_eh_frame != NULL)
12335     maybe_strip_output (info, htab->glink_eh_frame);
12336
12337   return TRUE;
12338 }
12339
12340 /* Called after we have determined section placement.  If sections
12341    move, we'll be called again.  Provide a value for TOCstart.  */
12342
12343 bfd_vma
12344 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12345 {
12346   asection *s;
12347   bfd_vma TOCstart;
12348
12349   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12350      order.  The TOC starts where the first of these sections starts.  */
12351   s = bfd_get_section_by_name (obfd, ".got");
12352   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12353     s = bfd_get_section_by_name (obfd, ".toc");
12354   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12355     s = bfd_get_section_by_name (obfd, ".tocbss");
12356   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12357     s = bfd_get_section_by_name (obfd, ".plt");
12358   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12359     {
12360       /* This may happen for
12361          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12362          .toc directive
12363          o  bad linker script
12364          o --gc-sections and empty TOC sections
12365
12366          FIXME: Warn user?  */
12367
12368       /* Look for a likely section.  We probably won't even be
12369          using TOCstart.  */
12370       for (s = obfd->sections; s != NULL; s = s->next)
12371         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12372                          | SEC_EXCLUDE))
12373             == (SEC_ALLOC | SEC_SMALL_DATA))
12374           break;
12375       if (s == NULL)
12376         for (s = obfd->sections; s != NULL; s = s->next)
12377           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12378               == (SEC_ALLOC | SEC_SMALL_DATA))
12379             break;
12380       if (s == NULL)
12381         for (s = obfd->sections; s != NULL; s = s->next)
12382           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12383               == SEC_ALLOC)
12384             break;
12385       if (s == NULL)
12386         for (s = obfd->sections; s != NULL; s = s->next)
12387           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12388             break;
12389     }
12390
12391   TOCstart = 0;
12392   if (s != NULL)
12393     TOCstart = s->output_section->vma + s->output_offset;
12394
12395   _bfd_set_gp_value (obfd, TOCstart);
12396
12397   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12398     {
12399       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12400
12401       if (htab != NULL
12402           && htab->elf.hgot != NULL)
12403         {
12404           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12405           htab->elf.hgot->root.u.def.section = s;
12406         }
12407     }
12408   return TOCstart;
12409 }
12410
12411 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12412    write out any global entry stubs.  */
12413
12414 static bfd_boolean
12415 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12416 {
12417   struct bfd_link_info *info;
12418   struct ppc_link_hash_table *htab;
12419   struct plt_entry *pent;
12420   asection *s;
12421
12422   if (h->root.type == bfd_link_hash_indirect)
12423     return TRUE;
12424
12425   if (!h->pointer_equality_needed)
12426     return TRUE;
12427
12428   if (h->def_regular)
12429     return TRUE;
12430
12431   info = inf;
12432   htab = ppc_hash_table (info);
12433   if (htab == NULL)
12434     return FALSE;
12435
12436   s = htab->glink;
12437   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12438     if (pent->plt.offset != (bfd_vma) -1
12439         && pent->addend == 0)
12440       {
12441         bfd_byte *p;
12442         asection *plt;
12443         bfd_vma off;
12444
12445         p = s->contents + h->root.u.def.value;
12446         plt = htab->elf.splt;
12447         if (!htab->elf.dynamic_sections_created
12448             || h->dynindx == -1)
12449           plt = htab->elf.iplt;
12450         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12451         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12452
12453         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12454           {
12455             info->callbacks->einfo
12456               (_("%P: linkage table error against `%T'\n"),
12457                h->root.root.string);
12458             bfd_set_error (bfd_error_bad_value);
12459             htab->stub_error = TRUE;
12460           }
12461
12462         if (PPC_HA (off) != 0)
12463           {
12464             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12465             p += 4;
12466           }
12467         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12468         p += 4;
12469         bfd_put_32 (s->owner, MTCTR_R12, p);
12470         p += 4;
12471         bfd_put_32 (s->owner, BCTR, p);
12472         break;
12473       }
12474   return TRUE;
12475 }
12476
12477 /* Build all the stubs associated with the current output file.
12478    The stubs are kept in a hash table attached to the main linker
12479    hash table.  This function is called via gldelf64ppc_finish.  */
12480
12481 bfd_boolean
12482 ppc64_elf_build_stubs (struct bfd_link_info *info,
12483                        char **stats)
12484 {
12485   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12486   asection *stub_sec;
12487   bfd_byte *p;
12488   int stub_sec_count = 0;
12489
12490   if (htab == NULL)
12491     return FALSE;
12492
12493   /* Allocate memory to hold the linker stubs.  */
12494   for (stub_sec = htab->params->stub_bfd->sections;
12495        stub_sec != NULL;
12496        stub_sec = stub_sec->next)
12497     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12498         && stub_sec->size != 0)
12499       {
12500         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12501         if (stub_sec->contents == NULL)
12502           return FALSE;
12503         /* We want to check that built size is the same as calculated
12504            size.  rawsize is a convenient location to use.  */
12505         stub_sec->rawsize = stub_sec->size;
12506         stub_sec->size = 0;
12507       }
12508
12509   if (htab->glink != NULL && htab->glink->size != 0)
12510     {
12511       unsigned int indx;
12512       bfd_vma plt0;
12513
12514       /* Build the .glink plt call stub.  */
12515       if (htab->params->emit_stub_syms)
12516         {
12517           struct elf_link_hash_entry *h;
12518           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12519                                     TRUE, FALSE, FALSE);
12520           if (h == NULL)
12521             return FALSE;
12522           if (h->root.type == bfd_link_hash_new)
12523             {
12524               h->root.type = bfd_link_hash_defined;
12525               h->root.u.def.section = htab->glink;
12526               h->root.u.def.value = 8;
12527               h->ref_regular = 1;
12528               h->def_regular = 1;
12529               h->ref_regular_nonweak = 1;
12530               h->forced_local = 1;
12531               h->non_elf = 0;
12532             }
12533         }
12534       plt0 = (htab->elf.splt->output_section->vma
12535               + htab->elf.splt->output_offset
12536               - 16);
12537       if (info->emitrelocations)
12538         {
12539           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12540           if (r == NULL)
12541             return FALSE;
12542           r->r_offset = (htab->glink->output_offset
12543                          + htab->glink->output_section->vma);
12544           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12545           r->r_addend = plt0;
12546         }
12547       p = htab->glink->contents;
12548       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12549       bfd_put_64 (htab->glink->owner, plt0, p);
12550       p += 8;
12551       if (htab->opd_abi)
12552         {
12553           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12554           p += 4;
12555           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12556           p += 4;
12557           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12558           p += 4;
12559           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12560           p += 4;
12561           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12562           p += 4;
12563           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12564           p += 4;
12565           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12566           p += 4;
12567           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12568           p += 4;
12569           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12570           p += 4;
12571           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12572           p += 4;
12573         }
12574       else
12575         {
12576           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12577           p += 4;
12578           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12579           p += 4;
12580           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12581           p += 4;
12582           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12583           p += 4;
12584           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12585           p += 4;
12586           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12587           p += 4;
12588           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12589           p += 4;
12590           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12591           p += 4;
12592           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12593           p += 4;
12594           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12595           p += 4;
12596           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12597           p += 4;
12598           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12599           p += 4;
12600         }
12601       bfd_put_32 (htab->glink->owner, BCTR, p);
12602       p += 4;
12603       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12604         {
12605           bfd_put_32 (htab->glink->owner, NOP, p);
12606           p += 4;
12607         }
12608
12609       /* Build the .glink lazy link call stubs.  */
12610       indx = 0;
12611       while (p < htab->glink->contents + htab->glink->rawsize)
12612         {
12613           if (htab->opd_abi)
12614             {
12615               if (indx < 0x8000)
12616                 {
12617                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12618                   p += 4;
12619                 }
12620               else
12621                 {
12622                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12623                   p += 4;
12624                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12625                               p);
12626                   p += 4;
12627                 }
12628             }
12629           bfd_put_32 (htab->glink->owner,
12630                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12631           indx++;
12632           p += 4;
12633         }
12634
12635       /* Build .glink global entry stubs.  */
12636       if (htab->glink->size > htab->glink->rawsize)
12637         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12638     }
12639
12640   if (htab->brlt->size != 0)
12641     {
12642       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12643                                          htab->brlt->size);
12644       if (htab->brlt->contents == NULL)
12645         return FALSE;
12646     }
12647   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12648     {
12649       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12650                                             htab->relbrlt->size);
12651       if (htab->relbrlt->contents == NULL)
12652         return FALSE;
12653     }
12654
12655   if (htab->glink_eh_frame != NULL
12656       && htab->glink_eh_frame->size != 0)
12657     {
12658       bfd_vma val;
12659       bfd_byte *last_fde;
12660       size_t last_fde_len, size, align, pad;
12661
12662       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12663       if (p == NULL)
12664         return FALSE;
12665       htab->glink_eh_frame->contents = p;
12666       last_fde = p;
12667
12668       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12669
12670       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12671       /* CIE length (rewrite in case little-endian).  */
12672       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12673       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12674       p += sizeof (glink_eh_frame_cie);
12675
12676       for (stub_sec = htab->params->stub_bfd->sections;
12677            stub_sec != NULL;
12678            stub_sec = stub_sec->next)
12679         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12680           {
12681             last_fde = p;
12682             last_fde_len = 16;
12683             /* FDE length.  */
12684             bfd_put_32 (htab->elf.dynobj, 16, p);
12685             p += 4;
12686             /* CIE pointer.  */
12687             val = p - htab->glink_eh_frame->contents;
12688             bfd_put_32 (htab->elf.dynobj, val, p);
12689             p += 4;
12690             /* Offset to stub section.  */
12691             val = (stub_sec->output_section->vma
12692                    + stub_sec->output_offset);
12693             val -= (htab->glink_eh_frame->output_section->vma
12694                     + htab->glink_eh_frame->output_offset);
12695             val -= p - htab->glink_eh_frame->contents;
12696             if (val + 0x80000000 > 0xffffffff)
12697               {
12698                 info->callbacks->einfo
12699                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12700                    stub_sec->name);
12701                 return FALSE;
12702               }
12703             bfd_put_32 (htab->elf.dynobj, val, p);
12704             p += 4;
12705             /* stub section size.  */
12706             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12707             p += 4;
12708             /* Augmentation.  */
12709             p += 1;
12710             /* Pad.  */
12711             p += 3;
12712           }
12713       if (htab->glink != NULL && htab->glink->size != 0)
12714         {
12715           last_fde = p;
12716           last_fde_len = 20;
12717           /* FDE length.  */
12718           bfd_put_32 (htab->elf.dynobj, 20, p);
12719           p += 4;
12720           /* CIE pointer.  */
12721           val = p - htab->glink_eh_frame->contents;
12722           bfd_put_32 (htab->elf.dynobj, val, p);
12723           p += 4;
12724           /* Offset to .glink.  */
12725           val = (htab->glink->output_section->vma
12726                  + htab->glink->output_offset
12727                  + 8);
12728           val -= (htab->glink_eh_frame->output_section->vma
12729                   + htab->glink_eh_frame->output_offset);
12730           val -= p - htab->glink_eh_frame->contents;
12731           if (val + 0x80000000 > 0xffffffff)
12732             {
12733               info->callbacks->einfo
12734                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12735                  htab->glink->name);
12736               return FALSE;
12737             }
12738           bfd_put_32 (htab->elf.dynobj, val, p);
12739           p += 4;
12740           /* .glink size.  */
12741           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12742           p += 4;
12743           /* Augmentation.  */
12744           p += 1;
12745
12746           *p++ = DW_CFA_advance_loc + 1;
12747           *p++ = DW_CFA_register;
12748           *p++ = 65;
12749           *p++ = 12;
12750           *p++ = DW_CFA_advance_loc + 4;
12751           *p++ = DW_CFA_restore_extended;
12752           *p++ = 65;
12753         }
12754       /* Subsume any padding into the last FDE if user .eh_frame
12755          sections are aligned more than glink_eh_frame.  Otherwise any
12756          zero padding will be seen as a terminator.  */
12757       size = p - htab->glink_eh_frame->contents;
12758       align = 1;
12759       align <<= htab->glink_eh_frame->output_section->alignment_power;
12760       align -= 1;
12761       pad = ((size + align) & ~align) - size;
12762       htab->glink_eh_frame->size = size + pad;
12763       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12764     }
12765
12766   /* Build the stubs as directed by the stub hash table.  */
12767   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12768
12769   if (htab->relbrlt != NULL)
12770     htab->relbrlt->reloc_count = 0;
12771
12772   if (htab->params->plt_stub_align != 0)
12773     for (stub_sec = htab->params->stub_bfd->sections;
12774          stub_sec != NULL;
12775          stub_sec = stub_sec->next)
12776       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12777         stub_sec->size = ((stub_sec->size
12778                            + (1 << htab->params->plt_stub_align) - 1)
12779                           & (-1 << htab->params->plt_stub_align));
12780
12781   for (stub_sec = htab->params->stub_bfd->sections;
12782        stub_sec != NULL;
12783        stub_sec = stub_sec->next)
12784     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12785       {
12786         stub_sec_count += 1;
12787         if (stub_sec->rawsize != stub_sec->size)
12788           break;
12789       }
12790
12791   if (stub_sec != NULL
12792       || (htab->glink_eh_frame != NULL
12793           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12794     {
12795       htab->stub_error = TRUE;
12796       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12797     }
12798
12799   if (htab->stub_error)
12800     return FALSE;
12801
12802   if (stats != NULL)
12803     {
12804       *stats = bfd_malloc (500);
12805       if (*stats == NULL)
12806         return FALSE;
12807
12808       sprintf (*stats, _("linker stubs in %u group%s\n"
12809                          "  branch       %lu\n"
12810                          "  toc adjust   %lu\n"
12811                          "  long branch  %lu\n"
12812                          "  long toc adj %lu\n"
12813                          "  plt call     %lu\n"
12814                          "  plt call toc %lu"),
12815                stub_sec_count,
12816                stub_sec_count == 1 ? "" : "s",
12817                htab->stub_count[ppc_stub_long_branch - 1],
12818                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12819                htab->stub_count[ppc_stub_plt_branch - 1],
12820                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12821                htab->stub_count[ppc_stub_plt_call - 1],
12822                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12823     }
12824   return TRUE;
12825 }
12826
12827 /* This function undoes the changes made by add_symbol_adjust.  */
12828
12829 static bfd_boolean
12830 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12831 {
12832   struct ppc_link_hash_entry *eh;
12833
12834   if (h->root.type == bfd_link_hash_indirect)
12835     return TRUE;
12836
12837   eh = (struct ppc_link_hash_entry *) h;
12838   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12839     return TRUE;
12840
12841   eh->elf.root.type = bfd_link_hash_undefined;
12842   return TRUE;
12843 }
12844
12845 void
12846 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12847 {
12848   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12849
12850   if (htab != NULL)
12851     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12852 }
12853
12854 /* What to do when ld finds relocations against symbols defined in
12855    discarded sections.  */
12856
12857 static unsigned int
12858 ppc64_elf_action_discarded (asection *sec)
12859 {
12860   if (strcmp (".opd", sec->name) == 0)
12861     return 0;
12862
12863   if (strcmp (".toc", sec->name) == 0)
12864     return 0;
12865
12866   if (strcmp (".toc1", sec->name) == 0)
12867     return 0;
12868
12869   return _bfd_elf_default_action_discarded (sec);
12870 }
12871
12872 /* The RELOCATE_SECTION function is called by the ELF backend linker
12873    to handle the relocations for a section.
12874
12875    The relocs are always passed as Rela structures; if the section
12876    actually uses Rel structures, the r_addend field will always be
12877    zero.
12878
12879    This function is responsible for adjust the section contents as
12880    necessary, and (if using Rela relocs and generating a
12881    relocatable output file) adjusting the reloc addend as
12882    necessary.
12883
12884    This function does not have to worry about setting the reloc
12885    address or the reloc symbol index.
12886
12887    LOCAL_SYMS is a pointer to the swapped in local symbols.
12888
12889    LOCAL_SECTIONS is an array giving the section in the input file
12890    corresponding to the st_shndx field of each local symbol.
12891
12892    The global hash table entry for the global symbols can be found
12893    via elf_sym_hashes (input_bfd).
12894
12895    When generating relocatable output, this function must handle
12896    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12897    going to be the section symbol corresponding to the output
12898    section, which means that the addend must be adjusted
12899    accordingly.  */
12900
12901 static bfd_boolean
12902 ppc64_elf_relocate_section (bfd *output_bfd,
12903                             struct bfd_link_info *info,
12904                             bfd *input_bfd,
12905                             asection *input_section,
12906                             bfd_byte *contents,
12907                             Elf_Internal_Rela *relocs,
12908                             Elf_Internal_Sym *local_syms,
12909                             asection **local_sections)
12910 {
12911   struct ppc_link_hash_table *htab;
12912   Elf_Internal_Shdr *symtab_hdr;
12913   struct elf_link_hash_entry **sym_hashes;
12914   Elf_Internal_Rela *rel;
12915   Elf_Internal_Rela *relend;
12916   Elf_Internal_Rela outrel;
12917   bfd_byte *loc;
12918   struct got_entry **local_got_ents;
12919   bfd_vma TOCstart;
12920   bfd_boolean ret = TRUE;
12921   bfd_boolean is_opd;
12922   /* Assume 'at' branch hints.  */
12923   bfd_boolean is_isa_v2 = TRUE;
12924   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12925
12926   /* Initialize howto table if needed.  */
12927   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12928     ppc_howto_init ();
12929
12930   htab = ppc_hash_table (info);
12931   if (htab == NULL)
12932     return FALSE;
12933
12934   /* Don't relocate stub sections.  */
12935   if (input_section->owner == htab->params->stub_bfd)
12936     return TRUE;
12937
12938   BFD_ASSERT (is_ppc64_elf (input_bfd));
12939
12940   local_got_ents = elf_local_got_ents (input_bfd);
12941   TOCstart = elf_gp (output_bfd);
12942   symtab_hdr = &elf_symtab_hdr (input_bfd);
12943   sym_hashes = elf_sym_hashes (input_bfd);
12944   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12945
12946   rel = relocs;
12947   relend = relocs + input_section->reloc_count;
12948   for (; rel < relend; rel++)
12949     {
12950       enum elf_ppc64_reloc_type r_type;
12951       bfd_vma addend;
12952       bfd_reloc_status_type r;
12953       Elf_Internal_Sym *sym;
12954       asection *sec;
12955       struct elf_link_hash_entry *h_elf;
12956       struct ppc_link_hash_entry *h;
12957       struct ppc_link_hash_entry *fdh;
12958       const char *sym_name;
12959       unsigned long r_symndx, toc_symndx;
12960       bfd_vma toc_addend;
12961       unsigned char tls_mask, tls_gd, tls_type;
12962       unsigned char sym_type;
12963       bfd_vma relocation;
12964       bfd_boolean unresolved_reloc;
12965       bfd_boolean warned;
12966       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12967       unsigned int insn;
12968       unsigned int mask;
12969       struct ppc_stub_hash_entry *stub_entry;
12970       bfd_vma max_br_offset;
12971       bfd_vma from;
12972       const Elf_Internal_Rela orig_rel = *rel;
12973       reloc_howto_type *howto;
12974       struct reloc_howto_struct alt_howto;
12975
12976       r_type = ELF64_R_TYPE (rel->r_info);
12977       r_symndx = ELF64_R_SYM (rel->r_info);
12978
12979       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12980          symbol of the previous ADDR64 reloc.  The symbol gives us the
12981          proper TOC base to use.  */
12982       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12983           && rel != relocs
12984           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12985           && is_opd)
12986         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12987
12988       sym = NULL;
12989       sec = NULL;
12990       h_elf = NULL;
12991       sym_name = NULL;
12992       unresolved_reloc = FALSE;
12993       warned = FALSE;
12994
12995       if (r_symndx < symtab_hdr->sh_info)
12996         {
12997           /* It's a local symbol.  */
12998           struct _opd_sec_data *opd;
12999
13000           sym = local_syms + r_symndx;
13001           sec = local_sections[r_symndx];
13002           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13003           sym_type = ELF64_ST_TYPE (sym->st_info);
13004           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13005           opd = get_opd_info (sec);
13006           if (opd != NULL && opd->adjust != NULL)
13007             {
13008               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13009               if (adjust == -1)
13010                 relocation = 0;
13011               else
13012                 {
13013                   /* If this is a relocation against the opd section sym
13014                      and we have edited .opd, adjust the reloc addend so
13015                      that ld -r and ld --emit-relocs output is correct.
13016                      If it is a reloc against some other .opd symbol,
13017                      then the symbol value will be adjusted later.  */
13018                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13019                     rel->r_addend += adjust;
13020                   else
13021                     relocation += adjust;
13022                 }
13023             }
13024         }
13025       else
13026         {
13027           bfd_boolean ignored;
13028
13029           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13030                                    r_symndx, symtab_hdr, sym_hashes,
13031                                    h_elf, sec, relocation,
13032                                    unresolved_reloc, warned, ignored);
13033           sym_name = h_elf->root.root.string;
13034           sym_type = h_elf->type;
13035           if (sec != NULL
13036               && sec->owner == output_bfd
13037               && strcmp (sec->name, ".opd") == 0)
13038             {
13039               /* This is a symbol defined in a linker script.  All
13040                  such are defined in output sections, even those
13041                  defined by simple assignment from a symbol defined in
13042                  an input section.  Transfer the symbol to an
13043                  appropriate input .opd section, so that a branch to
13044                  this symbol will be mapped to the location specified
13045                  by the opd entry.  */
13046               struct bfd_link_order *lo;
13047               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13048                 if (lo->type == bfd_indirect_link_order)
13049                   {
13050                     asection *isec = lo->u.indirect.section;
13051                     if (h_elf->root.u.def.value >= isec->output_offset
13052                         && h_elf->root.u.def.value < (isec->output_offset
13053                                                       + isec->size))
13054                       {
13055                         h_elf->root.u.def.value -= isec->output_offset;
13056                         h_elf->root.u.def.section = isec;
13057                         sec = isec;
13058                         break;
13059                       }
13060                   }
13061             }
13062         }
13063       h = (struct ppc_link_hash_entry *) h_elf;
13064
13065       if (sec != NULL && discarded_section (sec))
13066         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13067                                          rel, 1, relend,
13068                                          ppc64_elf_howto_table[r_type], 0,
13069                                          contents);
13070
13071       if (info->relocatable)
13072         continue;
13073
13074       if (h != NULL && &h->elf == htab->elf.hgot)
13075         {
13076           relocation = (TOCstart
13077                         + htab->stub_group[input_section->id].toc_off);
13078           sec = bfd_abs_section_ptr;
13079           unresolved_reloc = FALSE;
13080         }
13081
13082       /* TLS optimizations.  Replace instruction sequences and relocs
13083          based on information we collected in tls_optimize.  We edit
13084          RELOCS so that --emit-relocs will output something sensible
13085          for the final instruction stream.  */
13086       tls_mask = 0;
13087       tls_gd = 0;
13088       toc_symndx = 0;
13089       if (h != NULL)
13090         tls_mask = h->tls_mask;
13091       else if (local_got_ents != NULL)
13092         {
13093           struct plt_entry **local_plt = (struct plt_entry **)
13094             (local_got_ents + symtab_hdr->sh_info);
13095           unsigned char *lgot_masks = (unsigned char *)
13096             (local_plt + symtab_hdr->sh_info);
13097           tls_mask = lgot_masks[r_symndx];
13098         }
13099       if (tls_mask == 0
13100           && (r_type == R_PPC64_TLS
13101               || r_type == R_PPC64_TLSGD
13102               || r_type == R_PPC64_TLSLD))
13103         {
13104           /* Check for toc tls entries.  */
13105           unsigned char *toc_tls;
13106
13107           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13108                              &local_syms, rel, input_bfd))
13109             return FALSE;
13110
13111           if (toc_tls)
13112             tls_mask = *toc_tls;
13113         }
13114
13115       /* Check that tls relocs are used with tls syms, and non-tls
13116          relocs are used with non-tls syms.  */
13117       if (r_symndx != STN_UNDEF
13118           && r_type != R_PPC64_NONE
13119           && (h == NULL
13120               || h->elf.root.type == bfd_link_hash_defined
13121               || h->elf.root.type == bfd_link_hash_defweak)
13122           && (IS_PPC64_TLS_RELOC (r_type)
13123               != (sym_type == STT_TLS
13124                   || (sym_type == STT_SECTION
13125                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13126         {
13127           if (tls_mask != 0
13128               && (r_type == R_PPC64_TLS
13129                   || r_type == R_PPC64_TLSGD
13130                   || r_type == R_PPC64_TLSLD))
13131             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13132             ;
13133           else
13134             info->callbacks->einfo
13135               (!IS_PPC64_TLS_RELOC (r_type)
13136                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13137                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13138                input_bfd, input_section, rel->r_offset,
13139                ppc64_elf_howto_table[r_type]->name,
13140                sym_name);
13141         }
13142
13143       /* Ensure reloc mapping code below stays sane.  */
13144       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13145           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13146           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13147           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13148           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13149           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13150           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13151           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13152           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13153           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13154         abort ();
13155
13156       switch (r_type)
13157         {
13158         default:
13159           break;
13160
13161         case R_PPC64_LO_DS_OPT:
13162           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13163           if ((insn & (0x3f << 26)) != 58u << 26)
13164             abort ();
13165           insn += (14u << 26) - (58u << 26);
13166           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13167           r_type = R_PPC64_TOC16_LO;
13168           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13169           break;
13170
13171         case R_PPC64_TOC16:
13172         case R_PPC64_TOC16_LO:
13173         case R_PPC64_TOC16_DS:
13174         case R_PPC64_TOC16_LO_DS:
13175           {
13176             /* Check for toc tls entries.  */
13177             unsigned char *toc_tls;
13178             int retval;
13179
13180             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13181                                    &local_syms, rel, input_bfd);
13182             if (retval == 0)
13183               return FALSE;
13184
13185             if (toc_tls)
13186               {
13187                 tls_mask = *toc_tls;
13188                 if (r_type == R_PPC64_TOC16_DS
13189                     || r_type == R_PPC64_TOC16_LO_DS)
13190                   {
13191                     if (tls_mask != 0
13192                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13193                       goto toctprel;
13194                   }
13195                 else
13196                   {
13197                     /* If we found a GD reloc pair, then we might be
13198                        doing a GD->IE transition.  */
13199                     if (retval == 2)
13200                       {
13201                         tls_gd = TLS_TPRELGD;
13202                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13203                           goto tls_ldgd_opt;
13204                       }
13205                     else if (retval == 3)
13206                       {
13207                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13208                           goto tls_ldgd_opt;
13209                       }
13210                   }
13211               }
13212           }
13213           break;
13214
13215         case R_PPC64_GOT_TPREL16_HI:
13216         case R_PPC64_GOT_TPREL16_HA:
13217           if (tls_mask != 0
13218               && (tls_mask & TLS_TPREL) == 0)
13219             {
13220               rel->r_offset -= d_offset;
13221               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13222               r_type = R_PPC64_NONE;
13223               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13224             }
13225           break;
13226
13227         case R_PPC64_GOT_TPREL16_DS:
13228         case R_PPC64_GOT_TPREL16_LO_DS:
13229           if (tls_mask != 0
13230               && (tls_mask & TLS_TPREL) == 0)
13231             {
13232             toctprel:
13233               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13234               insn &= 31 << 21;
13235               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13236               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13237               r_type = R_PPC64_TPREL16_HA;
13238               if (toc_symndx != 0)
13239                 {
13240                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13241                   rel->r_addend = toc_addend;
13242                   /* We changed the symbol.  Start over in order to
13243                      get h, sym, sec etc. right.  */
13244                   rel--;
13245                   continue;
13246                 }
13247               else
13248                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13249             }
13250           break;
13251
13252         case R_PPC64_TLS:
13253           if (tls_mask != 0
13254               && (tls_mask & TLS_TPREL) == 0)
13255             {
13256               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13257               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13258               if (insn == 0)
13259                 abort ();
13260               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13261               /* Was PPC64_TLS which sits on insn boundary, now
13262                  PPC64_TPREL16_LO which is at low-order half-word.  */
13263               rel->r_offset += d_offset;
13264               r_type = R_PPC64_TPREL16_LO;
13265               if (toc_symndx != 0)
13266                 {
13267                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13268                   rel->r_addend = toc_addend;
13269                   /* We changed the symbol.  Start over in order to
13270                      get h, sym, sec etc. right.  */
13271                   rel--;
13272                   continue;
13273                 }
13274               else
13275                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13276             }
13277           break;
13278
13279         case R_PPC64_GOT_TLSGD16_HI:
13280         case R_PPC64_GOT_TLSGD16_HA:
13281           tls_gd = TLS_TPRELGD;
13282           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13283             goto tls_gdld_hi;
13284           break;
13285
13286         case R_PPC64_GOT_TLSLD16_HI:
13287         case R_PPC64_GOT_TLSLD16_HA:
13288           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13289             {
13290             tls_gdld_hi:
13291               if ((tls_mask & tls_gd) != 0)
13292                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13293                           + R_PPC64_GOT_TPREL16_DS);
13294               else
13295                 {
13296                   rel->r_offset -= d_offset;
13297                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13298                   r_type = R_PPC64_NONE;
13299                 }
13300               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13301             }
13302           break;
13303
13304         case R_PPC64_GOT_TLSGD16:
13305         case R_PPC64_GOT_TLSGD16_LO:
13306           tls_gd = TLS_TPRELGD;
13307           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13308             goto tls_ldgd_opt;
13309           break;
13310
13311         case R_PPC64_GOT_TLSLD16:
13312         case R_PPC64_GOT_TLSLD16_LO:
13313           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13314             {
13315               unsigned int insn1, insn2, insn3;
13316               bfd_vma offset;
13317
13318             tls_ldgd_opt:
13319               offset = (bfd_vma) -1;
13320               /* If not using the newer R_PPC64_TLSGD/LD to mark
13321                  __tls_get_addr calls, we must trust that the call
13322                  stays with its arg setup insns, ie. that the next
13323                  reloc is the __tls_get_addr call associated with
13324                  the current reloc.  Edit both insns.  */
13325               if (input_section->has_tls_get_addr_call
13326                   && rel + 1 < relend
13327                   && branch_reloc_hash_match (input_bfd, rel + 1,
13328                                               htab->tls_get_addr,
13329                                               htab->tls_get_addr_fd))
13330                 offset = rel[1].r_offset;
13331               if ((tls_mask & tls_gd) != 0)
13332                 {
13333                   /* IE */
13334                   insn1 = bfd_get_32 (output_bfd,
13335                                       contents + rel->r_offset - d_offset);
13336                   insn1 &= (1 << 26) - (1 << 2);
13337                   insn1 |= 58 << 26;    /* ld */
13338                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13339                   if (offset != (bfd_vma) -1)
13340                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13341                   if ((tls_mask & TLS_EXPLICIT) == 0)
13342                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13343                               + R_PPC64_GOT_TPREL16_DS);
13344                   else
13345                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13346                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13347                 }
13348               else
13349                 {
13350                   /* LE */
13351                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13352                   insn2 = 0x38630000;   /* addi 3,3,0 */
13353                   if (tls_gd == 0)
13354                     {
13355                       /* Was an LD reloc.  */
13356                       if (toc_symndx)
13357                         sec = local_sections[toc_symndx];
13358                       for (r_symndx = 0;
13359                            r_symndx < symtab_hdr->sh_info;
13360                            r_symndx++)
13361                         if (local_sections[r_symndx] == sec)
13362                           break;
13363                       if (r_symndx >= symtab_hdr->sh_info)
13364                         r_symndx = STN_UNDEF;
13365                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13366                       if (r_symndx != STN_UNDEF)
13367                         rel->r_addend -= (local_syms[r_symndx].st_value
13368                                           + sec->output_offset
13369                                           + sec->output_section->vma);
13370                     }
13371                   else if (toc_symndx != 0)
13372                     {
13373                       r_symndx = toc_symndx;
13374                       rel->r_addend = toc_addend;
13375                     }
13376                   r_type = R_PPC64_TPREL16_HA;
13377                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13378                   if (offset != (bfd_vma) -1)
13379                     {
13380                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13381                                                     R_PPC64_TPREL16_LO);
13382                       rel[1].r_offset = offset + d_offset;
13383                       rel[1].r_addend = rel->r_addend;
13384                     }
13385                 }
13386               bfd_put_32 (output_bfd, insn1,
13387                           contents + rel->r_offset - d_offset);
13388               if (offset != (bfd_vma) -1)
13389                 {
13390                   insn3 = bfd_get_32 (output_bfd,
13391                                       contents + offset + 4);
13392                   if (insn3 == NOP
13393                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13394                     {
13395                       rel[1].r_offset += 4;
13396                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13397                       insn2 = NOP;
13398                     }
13399                   bfd_put_32 (output_bfd, insn2, contents + offset);
13400                 }
13401               if ((tls_mask & tls_gd) == 0
13402                   && (tls_gd == 0 || toc_symndx != 0))
13403                 {
13404                   /* We changed the symbol.  Start over in order
13405                      to get h, sym, sec etc. right.  */
13406                   rel--;
13407                   continue;
13408                 }
13409             }
13410           break;
13411
13412         case R_PPC64_TLSGD:
13413           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13414             {
13415               unsigned int insn2, insn3;
13416               bfd_vma offset = rel->r_offset;
13417
13418               if ((tls_mask & TLS_TPRELGD) != 0)
13419                 {
13420                   /* IE */
13421                   r_type = R_PPC64_NONE;
13422                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13423                 }
13424               else
13425                 {
13426                   /* LE */
13427                   if (toc_symndx != 0)
13428                     {
13429                       r_symndx = toc_symndx;
13430                       rel->r_addend = toc_addend;
13431                     }
13432                   r_type = R_PPC64_TPREL16_LO;
13433                   rel->r_offset = offset + d_offset;
13434                   insn2 = 0x38630000;   /* addi 3,3,0 */
13435                 }
13436               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13437               /* Zap the reloc on the _tls_get_addr call too.  */
13438               BFD_ASSERT (offset == rel[1].r_offset);
13439               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13440               insn3 = bfd_get_32 (output_bfd,
13441                                   contents + offset + 4);
13442               if (insn3 == NOP
13443                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13444                 {
13445                   rel->r_offset += 4;
13446                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13447                   insn2 = NOP;
13448                 }
13449               bfd_put_32 (output_bfd, insn2, contents + offset);
13450               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13451                 {
13452                   rel--;
13453                   continue;
13454                 }
13455             }
13456           break;
13457
13458         case R_PPC64_TLSLD:
13459           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13460             {
13461               unsigned int insn2, insn3;
13462               bfd_vma offset = rel->r_offset;
13463
13464               if (toc_symndx)
13465                 sec = local_sections[toc_symndx];
13466               for (r_symndx = 0;
13467                    r_symndx < symtab_hdr->sh_info;
13468                    r_symndx++)
13469                 if (local_sections[r_symndx] == sec)
13470                   break;
13471               if (r_symndx >= symtab_hdr->sh_info)
13472                 r_symndx = STN_UNDEF;
13473               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13474               if (r_symndx != STN_UNDEF)
13475                 rel->r_addend -= (local_syms[r_symndx].st_value
13476                                   + sec->output_offset
13477                                   + sec->output_section->vma);
13478
13479               r_type = R_PPC64_TPREL16_LO;
13480               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13481               rel->r_offset = offset + d_offset;
13482               /* Zap the reloc on the _tls_get_addr call too.  */
13483               BFD_ASSERT (offset == rel[1].r_offset);
13484               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13485               insn2 = 0x38630000;       /* addi 3,3,0 */
13486               insn3 = bfd_get_32 (output_bfd,
13487                                   contents + offset + 4);
13488               if (insn3 == NOP
13489                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13490                 {
13491                   rel->r_offset += 4;
13492                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13493                   insn2 = NOP;
13494                 }
13495               bfd_put_32 (output_bfd, insn2, contents + offset);
13496               rel--;
13497               continue;
13498             }
13499           break;
13500
13501         case R_PPC64_DTPMOD64:
13502           if (rel + 1 < relend
13503               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13504               && rel[1].r_offset == rel->r_offset + 8)
13505             {
13506               if ((tls_mask & TLS_GD) == 0)
13507                 {
13508                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13509                   if ((tls_mask & TLS_TPRELGD) != 0)
13510                     r_type = R_PPC64_TPREL64;
13511                   else
13512                     {
13513                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13514                       r_type = R_PPC64_NONE;
13515                     }
13516                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13517                 }
13518             }
13519           else
13520             {
13521               if ((tls_mask & TLS_LD) == 0)
13522                 {
13523                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13524                   r_type = R_PPC64_NONE;
13525                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13526                 }
13527             }
13528           break;
13529
13530         case R_PPC64_TPREL64:
13531           if ((tls_mask & TLS_TPREL) == 0)
13532             {
13533               r_type = R_PPC64_NONE;
13534               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13535             }
13536           break;
13537
13538         case R_PPC64_REL16_HA:
13539           /* If we are generating a non-PIC executable, edit
13540              .  0:      addis 2,12,.TOC.-0b@ha
13541              .          addi 2,2,.TOC.-0b@l
13542              used by ELFv2 global entry points to set up r2, to
13543              .          lis 2,.TOC.@ha
13544              .          addi 2,2,.TOC.@l
13545              if .TOC. is in range.  */
13546           if (!info->shared
13547               && h != NULL && &h->elf == htab->elf.hgot
13548               && rel + 1 < relend
13549               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13550               && rel[1].r_offset == rel->r_offset + 4
13551               && rel[1].r_addend == rel->r_addend + 4
13552               && relocation + 0x80008000 <= 0xffffffff)
13553             {
13554               unsigned int insn1, insn2;
13555               bfd_vma offset = rel->r_offset - d_offset;
13556               insn1 = bfd_get_32 (output_bfd, contents + offset);
13557               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13558               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13559                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13560                 {
13561                   r_type = R_PPC64_ADDR16_HA;
13562                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13563                   rel->r_addend -= d_offset;
13564                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13565                   rel[1].r_addend -= d_offset + 4;
13566                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13567                 }
13568             }
13569           break;
13570         }
13571
13572       /* Handle other relocations that tweak non-addend part of insn.  */
13573       insn = 0;
13574       max_br_offset = 1 << 25;
13575       addend = rel->r_addend;
13576       reloc_dest = DEST_NORMAL;
13577       switch (r_type)
13578         {
13579         default:
13580           break;
13581
13582         case R_PPC64_TOCSAVE:
13583           if (relocation + addend == (rel->r_offset
13584                                       + input_section->output_offset
13585                                       + input_section->output_section->vma)
13586               && tocsave_find (htab, NO_INSERT,
13587                                &local_syms, rel, input_bfd))
13588             {
13589               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13590               if (insn == NOP
13591                   || insn == CROR_151515 || insn == CROR_313131)
13592                 bfd_put_32 (input_bfd,
13593                             STD_R2_0R1 + STK_TOC (htab),
13594                             contents + rel->r_offset);
13595             }
13596           break;
13597
13598           /* Branch taken prediction relocations.  */
13599         case R_PPC64_ADDR14_BRTAKEN:
13600         case R_PPC64_REL14_BRTAKEN:
13601           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13602           /* Fall thru.  */
13603
13604           /* Branch not taken prediction relocations.  */
13605         case R_PPC64_ADDR14_BRNTAKEN:
13606         case R_PPC64_REL14_BRNTAKEN:
13607           insn |= bfd_get_32 (output_bfd,
13608                               contents + rel->r_offset) & ~(0x01 << 21);
13609           /* Fall thru.  */
13610
13611         case R_PPC64_REL14:
13612           max_br_offset = 1 << 15;
13613           /* Fall thru.  */
13614
13615         case R_PPC64_REL24:
13616           /* Calls to functions with a different TOC, such as calls to
13617              shared objects, need to alter the TOC pointer.  This is
13618              done using a linkage stub.  A REL24 branching to these
13619              linkage stubs needs to be followed by a nop, as the nop
13620              will be replaced with an instruction to restore the TOC
13621              base pointer.  */
13622           fdh = h;
13623           if (h != NULL
13624               && h->oh != NULL
13625               && h->oh->is_func_descriptor)
13626             fdh = ppc_follow_link (h->oh);
13627           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13628                                            htab);
13629           if (stub_entry != NULL
13630               && (stub_entry->stub_type == ppc_stub_plt_call
13631                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13632                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13633                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13634             {
13635               bfd_boolean can_plt_call = FALSE;
13636
13637               /* All of these stubs will modify r2, so there must be a
13638                  branch and link followed by a nop.  The nop is
13639                  replaced by an insn to restore r2.  */
13640               if (rel->r_offset + 8 <= input_section->size)
13641                 {
13642                   unsigned long br;
13643
13644                   br = bfd_get_32 (input_bfd,
13645                                    contents + rel->r_offset);
13646                   if ((br & 1) != 0)
13647                     {
13648                       unsigned long nop;
13649
13650                       nop = bfd_get_32 (input_bfd,
13651                                         contents + rel->r_offset + 4);
13652                       if (nop == NOP
13653                           || nop == CROR_151515 || nop == CROR_313131)
13654                         {
13655                           if (h != NULL
13656                               && (h == htab->tls_get_addr_fd
13657                                   || h == htab->tls_get_addr)
13658                               && !htab->params->no_tls_get_addr_opt)
13659                             {
13660                               /* Special stub used, leave nop alone.  */
13661                             }
13662                           else
13663                             bfd_put_32 (input_bfd,
13664                                         LD_R2_0R1 + STK_TOC (htab),
13665                                         contents + rel->r_offset + 4);
13666                           can_plt_call = TRUE;
13667                         }
13668                     }
13669                 }
13670
13671               if (!can_plt_call && h != NULL)
13672                 {
13673                   const char *name = h->elf.root.root.string;
13674
13675                   if (*name == '.')
13676                     ++name;
13677
13678                   if (strncmp (name, "__libc_start_main", 17) == 0
13679                       && (name[17] == 0 || name[17] == '@'))
13680                     {
13681                       /* Allow crt1 branch to go via a toc adjusting
13682                          stub.  Other calls that never return could do
13683                          the same, if we could detect such.  */
13684                       can_plt_call = TRUE;
13685                     }
13686                 }
13687
13688               if (!can_plt_call)
13689                 {
13690                   /* g++ as of 20130507 emits self-calls without a
13691                      following nop.  This is arguably wrong since we
13692                      have conflicting information.  On the one hand a
13693                      global symbol and on the other a local call
13694                      sequence, but don't error for this special case.
13695                      It isn't possible to cheaply verify we have
13696                      exactly such a call.  Allow all calls to the same
13697                      section.  */
13698                   asection *code_sec = sec;
13699
13700                   if (get_opd_info (sec) != NULL)
13701                     {
13702                       bfd_vma off = (relocation + addend
13703                                      - sec->output_section->vma
13704                                      - sec->output_offset);
13705
13706                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13707                     }
13708                   if (code_sec == input_section)
13709                     can_plt_call = TRUE;
13710                 }
13711
13712               if (!can_plt_call)
13713                 {
13714                   info->callbacks->einfo
13715                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13716                        "recompile with -fPIC\n"),
13717                      input_bfd, input_section, rel->r_offset, sym_name);
13718
13719                   bfd_set_error (bfd_error_bad_value);
13720                   ret = FALSE;
13721                 }
13722
13723               if (can_plt_call
13724                   && (stub_entry->stub_type == ppc_stub_plt_call
13725                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13726                 unresolved_reloc = FALSE;
13727             }
13728
13729           if ((stub_entry == NULL
13730                || stub_entry->stub_type == ppc_stub_long_branch
13731                || stub_entry->stub_type == ppc_stub_plt_branch)
13732               && get_opd_info (sec) != NULL)
13733             {
13734               /* The branch destination is the value of the opd entry. */
13735               bfd_vma off = (relocation + addend
13736                              - sec->output_section->vma
13737                              - sec->output_offset);
13738               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13739               if (dest != (bfd_vma) -1)
13740                 {
13741                   relocation = dest;
13742                   addend = 0;
13743                   reloc_dest = DEST_OPD;
13744                 }
13745             }
13746
13747           /* If the branch is out of reach we ought to have a long
13748              branch stub.  */
13749           from = (rel->r_offset
13750                   + input_section->output_offset
13751                   + input_section->output_section->vma);
13752
13753           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13754                                                   ? fdh->elf.other
13755                                                   : sym->st_other);
13756
13757           if (stub_entry != NULL
13758               && (stub_entry->stub_type == ppc_stub_long_branch
13759                   || stub_entry->stub_type == ppc_stub_plt_branch)
13760               && (r_type == R_PPC64_ADDR14_BRTAKEN
13761                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13762                   || (relocation + addend - from + max_br_offset
13763                       < 2 * max_br_offset)))
13764             /* Don't use the stub if this branch is in range.  */
13765             stub_entry = NULL;
13766
13767           if (stub_entry != NULL)
13768             {
13769               /* Munge up the value and addend so that we call the stub
13770                  rather than the procedure directly.  */
13771               relocation = (stub_entry->stub_offset
13772                             + stub_entry->stub_sec->output_offset
13773                             + stub_entry->stub_sec->output_section->vma);
13774               addend = 0;
13775               reloc_dest = DEST_STUB;
13776
13777               if ((stub_entry->stub_type == ppc_stub_plt_call
13778                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13779                   && (ALWAYS_EMIT_R2SAVE
13780                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13781                   && rel + 1 < relend
13782                   && rel[1].r_offset == rel->r_offset + 4
13783                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13784                 relocation += 4;
13785             }
13786
13787           if (insn != 0)
13788             {
13789               if (is_isa_v2)
13790                 {
13791                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13792                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13793                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13794                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13795                     insn |= 0x02 << 21;
13796                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13797                     insn |= 0x08 << 21;
13798                   else
13799                     break;
13800                 }
13801               else
13802                 {
13803                   /* Invert 'y' bit if not the default.  */
13804                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13805                     insn ^= 0x01 << 21;
13806                 }
13807
13808               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13809             }
13810
13811           /* NOP out calls to undefined weak functions.
13812              We can thus call a weak function without first
13813              checking whether the function is defined.  */
13814           else if (h != NULL
13815                    && h->elf.root.type == bfd_link_hash_undefweak
13816                    && h->elf.dynindx == -1
13817                    && r_type == R_PPC64_REL24
13818                    && relocation == 0
13819                    && addend == 0)
13820             {
13821               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13822               continue;
13823             }
13824           break;
13825         }
13826
13827       /* Set `addend'.  */
13828       tls_type = 0;
13829       switch (r_type)
13830         {
13831         default:
13832           info->callbacks->einfo
13833             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13834              input_bfd, (int) r_type, sym_name);
13835
13836           bfd_set_error (bfd_error_bad_value);
13837           ret = FALSE;
13838           continue;
13839
13840         case R_PPC64_NONE:
13841         case R_PPC64_TLS:
13842         case R_PPC64_TLSGD:
13843         case R_PPC64_TLSLD:
13844         case R_PPC64_TOCSAVE:
13845         case R_PPC64_GNU_VTINHERIT:
13846         case R_PPC64_GNU_VTENTRY:
13847           continue;
13848
13849           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13850              address in the GOT as relocation value instead of the
13851              symbol's value itself.  Also, create a GOT entry for the
13852              symbol and put the symbol value there.  */
13853         case R_PPC64_GOT_TLSGD16:
13854         case R_PPC64_GOT_TLSGD16_LO:
13855         case R_PPC64_GOT_TLSGD16_HI:
13856         case R_PPC64_GOT_TLSGD16_HA:
13857           tls_type = TLS_TLS | TLS_GD;
13858           goto dogot;
13859
13860         case R_PPC64_GOT_TLSLD16:
13861         case R_PPC64_GOT_TLSLD16_LO:
13862         case R_PPC64_GOT_TLSLD16_HI:
13863         case R_PPC64_GOT_TLSLD16_HA:
13864           tls_type = TLS_TLS | TLS_LD;
13865           goto dogot;
13866
13867         case R_PPC64_GOT_TPREL16_DS:
13868         case R_PPC64_GOT_TPREL16_LO_DS:
13869         case R_PPC64_GOT_TPREL16_HI:
13870         case R_PPC64_GOT_TPREL16_HA:
13871           tls_type = TLS_TLS | TLS_TPREL;
13872           goto dogot;
13873
13874         case R_PPC64_GOT_DTPREL16_DS:
13875         case R_PPC64_GOT_DTPREL16_LO_DS:
13876         case R_PPC64_GOT_DTPREL16_HI:
13877         case R_PPC64_GOT_DTPREL16_HA:
13878           tls_type = TLS_TLS | TLS_DTPREL;
13879           goto dogot;
13880
13881         case R_PPC64_GOT16:
13882         case R_PPC64_GOT16_LO:
13883         case R_PPC64_GOT16_HI:
13884         case R_PPC64_GOT16_HA:
13885         case R_PPC64_GOT16_DS:
13886         case R_PPC64_GOT16_LO_DS:
13887         dogot:
13888           {
13889             /* Relocation is to the entry for this symbol in the global
13890                offset table.  */
13891             asection *got;
13892             bfd_vma *offp;
13893             bfd_vma off;
13894             unsigned long indx = 0;
13895             struct got_entry *ent;
13896
13897             if (tls_type == (TLS_TLS | TLS_LD)
13898                 && (h == NULL
13899                     || !h->elf.def_dynamic))
13900               ent = ppc64_tlsld_got (input_bfd);
13901             else
13902               {
13903
13904                 if (h != NULL)
13905                   {
13906                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13907                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13908                                                           &h->elf)
13909                         || (info->shared
13910                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13911                       /* This is actually a static link, or it is a
13912                          -Bsymbolic link and the symbol is defined
13913                          locally, or the symbol was forced to be local
13914                          because of a version file.  */
13915                       ;
13916                     else
13917                       {
13918                         BFD_ASSERT (h->elf.dynindx != -1);
13919                         indx = h->elf.dynindx;
13920                         unresolved_reloc = FALSE;
13921                       }
13922                     ent = h->elf.got.glist;
13923                   }
13924                 else
13925                   {
13926                     if (local_got_ents == NULL)
13927                       abort ();
13928                     ent = local_got_ents[r_symndx];
13929                   }
13930
13931                 for (; ent != NULL; ent = ent->next)
13932                   if (ent->addend == orig_rel.r_addend
13933                       && ent->owner == input_bfd
13934                       && ent->tls_type == tls_type)
13935                     break;
13936               }
13937
13938             if (ent == NULL)
13939               abort ();
13940             if (ent->is_indirect)
13941               ent = ent->got.ent;
13942             offp = &ent->got.offset;
13943             got = ppc64_elf_tdata (ent->owner)->got;
13944             if (got == NULL)
13945               abort ();
13946
13947             /* The offset must always be a multiple of 8.  We use the
13948                least significant bit to record whether we have already
13949                processed this entry.  */
13950             off = *offp;
13951             if ((off & 1) != 0)
13952               off &= ~1;
13953             else
13954               {
13955                 /* Generate relocs for the dynamic linker, except in
13956                    the case of TLSLD where we'll use one entry per
13957                    module.  */
13958                 asection *relgot;
13959                 bfd_boolean ifunc;
13960
13961                 *offp = off | 1;
13962                 relgot = NULL;
13963                 ifunc = (h != NULL
13964                          ? h->elf.type == STT_GNU_IFUNC
13965                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13966                 if (ifunc)
13967                   relgot = htab->elf.irelplt;
13968                 else if ((info->shared || indx != 0)
13969                          && (h == NULL
13970                              || (tls_type == (TLS_TLS | TLS_LD)
13971                                  && !h->elf.def_dynamic)
13972                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13973                              || h->elf.root.type != bfd_link_hash_undefweak))
13974                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13975                 if (relgot != NULL)
13976                   {
13977                     outrel.r_offset = (got->output_section->vma
13978                                        + got->output_offset
13979                                        + off);
13980                     outrel.r_addend = addend;
13981                     if (tls_type & (TLS_LD | TLS_GD))
13982                       {
13983                         outrel.r_addend = 0;
13984                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13985                         if (tls_type == (TLS_TLS | TLS_GD))
13986                           {
13987                             loc = relgot->contents;
13988                             loc += (relgot->reloc_count++
13989                                     * sizeof (Elf64_External_Rela));
13990                             bfd_elf64_swap_reloca_out (output_bfd,
13991                                                        &outrel, loc);
13992                             outrel.r_offset += 8;
13993                             outrel.r_addend = addend;
13994                             outrel.r_info
13995                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13996                           }
13997                       }
13998                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13999                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14000                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14001                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14002                     else if (indx != 0)
14003                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14004                     else
14005                       {
14006                         if (ifunc)
14007                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14008                         else
14009                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14010
14011                         /* Write the .got section contents for the sake
14012                            of prelink.  */
14013                         loc = got->contents + off;
14014                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14015                                     loc);
14016                       }
14017
14018                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14019                       {
14020                         outrel.r_addend += relocation;
14021                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14022                           outrel.r_addend -= htab->elf.tls_sec->vma;
14023                       }
14024                     loc = relgot->contents;
14025                     loc += (relgot->reloc_count++
14026                             * sizeof (Elf64_External_Rela));
14027                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14028                   }
14029
14030                 /* Init the .got section contents here if we're not
14031                    emitting a reloc.  */
14032                 else
14033                   {
14034                     relocation += addend;
14035                     if (tls_type == (TLS_TLS | TLS_LD))
14036                       relocation = 1;
14037                     else if (tls_type != 0)
14038                       {
14039                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14040                         if (tls_type == (TLS_TLS | TLS_TPREL))
14041                           relocation += DTP_OFFSET - TP_OFFSET;
14042
14043                         if (tls_type == (TLS_TLS | TLS_GD))
14044                           {
14045                             bfd_put_64 (output_bfd, relocation,
14046                                         got->contents + off + 8);
14047                             relocation = 1;
14048                           }
14049                       }
14050
14051                     bfd_put_64 (output_bfd, relocation,
14052                                 got->contents + off);
14053                   }
14054               }
14055
14056             if (off >= (bfd_vma) -2)
14057               abort ();
14058
14059             relocation = got->output_section->vma + got->output_offset + off;
14060             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14061           }
14062           break;
14063
14064         case R_PPC64_PLT16_HA:
14065         case R_PPC64_PLT16_HI:
14066         case R_PPC64_PLT16_LO:
14067         case R_PPC64_PLT32:
14068         case R_PPC64_PLT64:
14069           /* Relocation is to the entry for this symbol in the
14070              procedure linkage table.  */
14071
14072           /* Resolve a PLT reloc against a local symbol directly,
14073              without using the procedure linkage table.  */
14074           if (h == NULL)
14075             break;
14076
14077           /* It's possible that we didn't make a PLT entry for this
14078              symbol.  This happens when statically linking PIC code,
14079              or when using -Bsymbolic.  Go find a match if there is a
14080              PLT entry.  */
14081           if (htab->elf.splt != NULL)
14082             {
14083               struct plt_entry *ent;
14084               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14085                 if (ent->plt.offset != (bfd_vma) -1
14086                     && ent->addend == orig_rel.r_addend)
14087                   {
14088                     relocation = (htab->elf.splt->output_section->vma
14089                                   + htab->elf.splt->output_offset
14090                                   + ent->plt.offset);
14091                     unresolved_reloc = FALSE;
14092                     break;
14093                   }
14094             }
14095           break;
14096
14097         case R_PPC64_TOC:
14098           /* Relocation value is TOC base.  */
14099           relocation = TOCstart;
14100           if (r_symndx == STN_UNDEF)
14101             relocation += htab->stub_group[input_section->id].toc_off;
14102           else if (unresolved_reloc)
14103             ;
14104           else if (sec != NULL && sec->id <= htab->top_id)
14105             relocation += htab->stub_group[sec->id].toc_off;
14106           else
14107             unresolved_reloc = TRUE;
14108           goto dodyn;
14109
14110           /* TOC16 relocs.  We want the offset relative to the TOC base,
14111              which is the address of the start of the TOC plus 0x8000.
14112              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14113              in this order.  */
14114         case R_PPC64_TOC16:
14115         case R_PPC64_TOC16_LO:
14116         case R_PPC64_TOC16_HI:
14117         case R_PPC64_TOC16_DS:
14118         case R_PPC64_TOC16_LO_DS:
14119         case R_PPC64_TOC16_HA:
14120           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14121           break;
14122
14123           /* Relocate against the beginning of the section.  */
14124         case R_PPC64_SECTOFF:
14125         case R_PPC64_SECTOFF_LO:
14126         case R_PPC64_SECTOFF_HI:
14127         case R_PPC64_SECTOFF_DS:
14128         case R_PPC64_SECTOFF_LO_DS:
14129         case R_PPC64_SECTOFF_HA:
14130           if (sec != NULL)
14131             addend -= sec->output_section->vma;
14132           break;
14133
14134         case R_PPC64_REL16:
14135         case R_PPC64_REL16_LO:
14136         case R_PPC64_REL16_HI:
14137         case R_PPC64_REL16_HA:
14138           break;
14139
14140         case R_PPC64_REL14:
14141         case R_PPC64_REL14_BRNTAKEN:
14142         case R_PPC64_REL14_BRTAKEN:
14143         case R_PPC64_REL24:
14144           break;
14145
14146         case R_PPC64_TPREL16:
14147         case R_PPC64_TPREL16_LO:
14148         case R_PPC64_TPREL16_HI:
14149         case R_PPC64_TPREL16_HA:
14150         case R_PPC64_TPREL16_DS:
14151         case R_PPC64_TPREL16_LO_DS:
14152         case R_PPC64_TPREL16_HIGH:
14153         case R_PPC64_TPREL16_HIGHA:
14154         case R_PPC64_TPREL16_HIGHER:
14155         case R_PPC64_TPREL16_HIGHERA:
14156         case R_PPC64_TPREL16_HIGHEST:
14157         case R_PPC64_TPREL16_HIGHESTA:
14158           if (h != NULL
14159               && h->elf.root.type == bfd_link_hash_undefweak
14160               && h->elf.dynindx == -1)
14161             {
14162               /* Make this relocation against an undefined weak symbol
14163                  resolve to zero.  This is really just a tweak, since
14164                  code using weak externs ought to check that they are
14165                  defined before using them.  */
14166               bfd_byte *p = contents + rel->r_offset - d_offset;
14167
14168               insn = bfd_get_32 (output_bfd, p);
14169               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14170               if (insn != 0)
14171                 bfd_put_32 (output_bfd, insn, p);
14172               break;
14173             }
14174           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14175           if (info->shared)
14176             /* The TPREL16 relocs shouldn't really be used in shared
14177                libs as they will result in DT_TEXTREL being set, but
14178                support them anyway.  */
14179             goto dodyn;
14180           break;
14181
14182         case R_PPC64_DTPREL16:
14183         case R_PPC64_DTPREL16_LO:
14184         case R_PPC64_DTPREL16_HI:
14185         case R_PPC64_DTPREL16_HA:
14186         case R_PPC64_DTPREL16_DS:
14187         case R_PPC64_DTPREL16_LO_DS:
14188         case R_PPC64_DTPREL16_HIGH:
14189         case R_PPC64_DTPREL16_HIGHA:
14190         case R_PPC64_DTPREL16_HIGHER:
14191         case R_PPC64_DTPREL16_HIGHERA:
14192         case R_PPC64_DTPREL16_HIGHEST:
14193         case R_PPC64_DTPREL16_HIGHESTA:
14194           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14195           break;
14196
14197         case R_PPC64_ADDR64_LOCAL:
14198           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14199                                               ? h->elf.other
14200                                               : sym->st_other);
14201           break;
14202
14203         case R_PPC64_DTPMOD64:
14204           relocation = 1;
14205           addend = 0;
14206           goto dodyn;
14207
14208         case R_PPC64_TPREL64:
14209           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14210           goto dodyn;
14211
14212         case R_PPC64_DTPREL64:
14213           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14214           /* Fall thru */
14215
14216           /* Relocations that may need to be propagated if this is a
14217              dynamic object.  */
14218         case R_PPC64_REL30:
14219         case R_PPC64_REL32:
14220         case R_PPC64_REL64:
14221         case R_PPC64_ADDR14:
14222         case R_PPC64_ADDR14_BRNTAKEN:
14223         case R_PPC64_ADDR14_BRTAKEN:
14224         case R_PPC64_ADDR16:
14225         case R_PPC64_ADDR16_DS:
14226         case R_PPC64_ADDR16_HA:
14227         case R_PPC64_ADDR16_HI:
14228         case R_PPC64_ADDR16_HIGH:
14229         case R_PPC64_ADDR16_HIGHA:
14230         case R_PPC64_ADDR16_HIGHER:
14231         case R_PPC64_ADDR16_HIGHERA:
14232         case R_PPC64_ADDR16_HIGHEST:
14233         case R_PPC64_ADDR16_HIGHESTA:
14234         case R_PPC64_ADDR16_LO:
14235         case R_PPC64_ADDR16_LO_DS:
14236         case R_PPC64_ADDR24:
14237         case R_PPC64_ADDR32:
14238         case R_PPC64_ADDR64:
14239         case R_PPC64_UADDR16:
14240         case R_PPC64_UADDR32:
14241         case R_PPC64_UADDR64:
14242         dodyn:
14243           if ((input_section->flags & SEC_ALLOC) == 0)
14244             break;
14245
14246           if (NO_OPD_RELOCS && is_opd)
14247             break;
14248
14249           if ((info->shared
14250                && (h == NULL
14251                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14252                    || h->elf.root.type != bfd_link_hash_undefweak)
14253                && (must_be_dyn_reloc (info, r_type)
14254                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14255               || (ELIMINATE_COPY_RELOCS
14256                   && !info->shared
14257                   && h != NULL
14258                   && h->elf.dynindx != -1
14259                   && !h->elf.non_got_ref
14260                   && !h->elf.def_regular)
14261               || (!info->shared
14262                   && (h != NULL
14263                       ? h->elf.type == STT_GNU_IFUNC
14264                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14265             {
14266               bfd_boolean skip, relocate;
14267               asection *sreloc;
14268               bfd_vma out_off;
14269
14270               /* When generating a dynamic object, these relocations
14271                  are copied into the output file to be resolved at run
14272                  time.  */
14273
14274               skip = FALSE;
14275               relocate = FALSE;
14276
14277               out_off = _bfd_elf_section_offset (output_bfd, info,
14278                                                  input_section, rel->r_offset);
14279               if (out_off == (bfd_vma) -1)
14280                 skip = TRUE;
14281               else if (out_off == (bfd_vma) -2)
14282                 skip = TRUE, relocate = TRUE;
14283               out_off += (input_section->output_section->vma
14284                           + input_section->output_offset);
14285               outrel.r_offset = out_off;
14286               outrel.r_addend = rel->r_addend;
14287
14288               /* Optimize unaligned reloc use.  */
14289               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14290                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14291                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14292               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14293                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14294                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14295               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14296                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14297                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14298
14299               if (skip)
14300                 memset (&outrel, 0, sizeof outrel);
14301               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14302                        && !is_opd
14303                        && r_type != R_PPC64_TOC)
14304                 {
14305                   BFD_ASSERT (h->elf.dynindx != -1);
14306                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14307                 }
14308               else
14309                 {
14310                   /* This symbol is local, or marked to become local,
14311                      or this is an opd section reloc which must point
14312                      at a local function.  */
14313                   outrel.r_addend += relocation;
14314                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14315                     {
14316                       if (is_opd && h != NULL)
14317                         {
14318                           /* Lie about opd entries.  This case occurs
14319                              when building shared libraries and we
14320                              reference a function in another shared
14321                              lib.  The same thing happens for a weak
14322                              definition in an application that's
14323                              overridden by a strong definition in a
14324                              shared lib.  (I believe this is a generic
14325                              bug in binutils handling of weak syms.)
14326                              In these cases we won't use the opd
14327                              entry in this lib.  */
14328                           unresolved_reloc = FALSE;
14329                         }
14330                       if (!is_opd
14331                           && r_type == R_PPC64_ADDR64
14332                           && (h != NULL
14333                               ? h->elf.type == STT_GNU_IFUNC
14334                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14335                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14336                       else
14337                         {
14338                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14339
14340                           /* We need to relocate .opd contents for ld.so.
14341                              Prelink also wants simple and consistent rules
14342                              for relocs.  This make all RELATIVE relocs have
14343                              *r_offset equal to r_addend.  */
14344                           relocate = TRUE;
14345                         }
14346                     }
14347                   else
14348                     {
14349                       long indx = 0;
14350
14351                       if (h != NULL
14352                           ? h->elf.type == STT_GNU_IFUNC
14353                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14354                         {
14355                           info->callbacks->einfo
14356                             (_("%P: %H: %s for indirect "
14357                                "function `%T' unsupported\n"),
14358                              input_bfd, input_section, rel->r_offset,
14359                              ppc64_elf_howto_table[r_type]->name,
14360                              sym_name);
14361                           ret = FALSE;
14362                         }
14363                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14364                         ;
14365                       else if (sec == NULL || sec->owner == NULL)
14366                         {
14367                           bfd_set_error (bfd_error_bad_value);
14368                           return FALSE;
14369                         }
14370                       else
14371                         {
14372                           asection *osec;
14373
14374                           osec = sec->output_section;
14375                           indx = elf_section_data (osec)->dynindx;
14376
14377                           if (indx == 0)
14378                             {
14379                               if ((osec->flags & SEC_READONLY) == 0
14380                                   && htab->elf.data_index_section != NULL)
14381                                 osec = htab->elf.data_index_section;
14382                               else
14383                                 osec = htab->elf.text_index_section;
14384                               indx = elf_section_data (osec)->dynindx;
14385                             }
14386                           BFD_ASSERT (indx != 0);
14387
14388                           /* We are turning this relocation into one
14389                              against a section symbol, so subtract out
14390                              the output section's address but not the
14391                              offset of the input section in the output
14392                              section.  */
14393                           outrel.r_addend -= osec->vma;
14394                         }
14395
14396                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14397                     }
14398                 }
14399
14400               sreloc = elf_section_data (input_section)->sreloc;
14401               if (h != NULL
14402                   ? h->elf.type == STT_GNU_IFUNC
14403                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14404                 sreloc = htab->elf.irelplt;
14405               if (sreloc == NULL)
14406                 abort ();
14407
14408               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14409                   >= sreloc->size)
14410                 abort ();
14411               loc = sreloc->contents;
14412               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14413               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14414
14415               /* If this reloc is against an external symbol, it will
14416                  be computed at runtime, so there's no need to do
14417                  anything now.  However, for the sake of prelink ensure
14418                  that the section contents are a known value.  */
14419               if (! relocate)
14420                 {
14421                   unresolved_reloc = FALSE;
14422                   /* The value chosen here is quite arbitrary as ld.so
14423                      ignores section contents except for the special
14424                      case of .opd where the contents might be accessed
14425                      before relocation.  Choose zero, as that won't
14426                      cause reloc overflow.  */
14427                   relocation = 0;
14428                   addend = 0;
14429                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14430                      to improve backward compatibility with older
14431                      versions of ld.  */
14432                   if (r_type == R_PPC64_ADDR64)
14433                     addend = outrel.r_addend;
14434                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14435                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14436                     addend = (input_section->output_section->vma
14437                               + input_section->output_offset
14438                               + rel->r_offset);
14439                 }
14440             }
14441           break;
14442
14443         case R_PPC64_COPY:
14444         case R_PPC64_GLOB_DAT:
14445         case R_PPC64_JMP_SLOT:
14446         case R_PPC64_JMP_IREL:
14447         case R_PPC64_RELATIVE:
14448           /* We shouldn't ever see these dynamic relocs in relocatable
14449              files.  */
14450           /* Fall through.  */
14451
14452         case R_PPC64_PLTGOT16:
14453         case R_PPC64_PLTGOT16_DS:
14454         case R_PPC64_PLTGOT16_HA:
14455         case R_PPC64_PLTGOT16_HI:
14456         case R_PPC64_PLTGOT16_LO:
14457         case R_PPC64_PLTGOT16_LO_DS:
14458         case R_PPC64_PLTREL32:
14459         case R_PPC64_PLTREL64:
14460           /* These ones haven't been implemented yet.  */
14461
14462           info->callbacks->einfo
14463             (_("%P: %B: %s is not supported for `%T'\n"),
14464              input_bfd,
14465              ppc64_elf_howto_table[r_type]->name, sym_name);
14466
14467           bfd_set_error (bfd_error_invalid_operation);
14468           ret = FALSE;
14469           continue;
14470         }
14471
14472       /* Multi-instruction sequences that access the TOC can be
14473          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14474          to             nop;           addi rb,r2,x;  */
14475       switch (r_type)
14476         {
14477         default:
14478           break;
14479
14480         case R_PPC64_GOT_TLSLD16_HI:
14481         case R_PPC64_GOT_TLSGD16_HI:
14482         case R_PPC64_GOT_TPREL16_HI:
14483         case R_PPC64_GOT_DTPREL16_HI:
14484         case R_PPC64_GOT16_HI:
14485         case R_PPC64_TOC16_HI:
14486           /* These relocs would only be useful if building up an
14487              offset to later add to r2, perhaps in an indexed
14488              addressing mode instruction.  Don't try to optimize.
14489              Unfortunately, the possibility of someone building up an
14490              offset like this or even with the HA relocs, means that
14491              we need to check the high insn when optimizing the low
14492              insn.  */
14493           break;
14494
14495         case R_PPC64_GOT_TLSLD16_HA:
14496         case R_PPC64_GOT_TLSGD16_HA:
14497         case R_PPC64_GOT_TPREL16_HA:
14498         case R_PPC64_GOT_DTPREL16_HA:
14499         case R_PPC64_GOT16_HA:
14500         case R_PPC64_TOC16_HA:
14501           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14502               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14503             {
14504               bfd_byte *p = contents + (rel->r_offset & ~3);
14505               bfd_put_32 (input_bfd, NOP, p);
14506             }
14507           break;
14508
14509         case R_PPC64_GOT_TLSLD16_LO:
14510         case R_PPC64_GOT_TLSGD16_LO:
14511         case R_PPC64_GOT_TPREL16_LO_DS:
14512         case R_PPC64_GOT_DTPREL16_LO_DS:
14513         case R_PPC64_GOT16_LO:
14514         case R_PPC64_GOT16_LO_DS:
14515         case R_PPC64_TOC16_LO:
14516         case R_PPC64_TOC16_LO_DS:
14517           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14518               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14519             {
14520               bfd_byte *p = contents + (rel->r_offset & ~3);
14521               insn = bfd_get_32 (input_bfd, p);
14522               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14523                 {
14524                   /* Transform addic to addi when we change reg.  */
14525                   insn &= ~((0x3f << 26) | (0x1f << 16));
14526                   insn |= (14u << 26) | (2 << 16);
14527                 }
14528               else
14529                 {
14530                   insn &= ~(0x1f << 16);
14531                   insn |= 2 << 16;
14532                 }
14533               bfd_put_32 (input_bfd, insn, p);
14534             }
14535           break;
14536         }
14537
14538       /* Do any further special processing.  */
14539       howto = ppc64_elf_howto_table[(int) r_type];
14540       switch (r_type)
14541         {
14542         default:
14543           break;
14544
14545         case R_PPC64_REL16_HA:
14546         case R_PPC64_ADDR16_HA:
14547         case R_PPC64_ADDR16_HIGHA:
14548         case R_PPC64_ADDR16_HIGHERA:
14549         case R_PPC64_ADDR16_HIGHESTA:
14550         case R_PPC64_TOC16_HA:
14551         case R_PPC64_SECTOFF_HA:
14552         case R_PPC64_TPREL16_HA:
14553         case R_PPC64_TPREL16_HIGHA:
14554         case R_PPC64_TPREL16_HIGHERA:
14555         case R_PPC64_TPREL16_HIGHESTA:
14556         case R_PPC64_DTPREL16_HA:
14557         case R_PPC64_DTPREL16_HIGHA:
14558         case R_PPC64_DTPREL16_HIGHERA:
14559         case R_PPC64_DTPREL16_HIGHESTA:
14560           /* It's just possible that this symbol is a weak symbol
14561              that's not actually defined anywhere. In that case,
14562              'sec' would be NULL, and we should leave the symbol
14563              alone (it will be set to zero elsewhere in the link).  */
14564           if (sec == NULL)
14565             break;
14566           /* Fall thru */
14567
14568         case R_PPC64_GOT16_HA:
14569         case R_PPC64_PLTGOT16_HA:
14570         case R_PPC64_PLT16_HA:
14571         case R_PPC64_GOT_TLSGD16_HA:
14572         case R_PPC64_GOT_TLSLD16_HA:
14573         case R_PPC64_GOT_TPREL16_HA:
14574         case R_PPC64_GOT_DTPREL16_HA:
14575           /* Add 0x10000 if sign bit in 0:15 is set.
14576              Bits 0:15 are not used.  */
14577           addend += 0x8000;
14578           break;
14579
14580         case R_PPC64_ADDR16_DS:
14581         case R_PPC64_ADDR16_LO_DS:
14582         case R_PPC64_GOT16_DS:
14583         case R_PPC64_GOT16_LO_DS:
14584         case R_PPC64_PLT16_LO_DS:
14585         case R_PPC64_SECTOFF_DS:
14586         case R_PPC64_SECTOFF_LO_DS:
14587         case R_PPC64_TOC16_DS:
14588         case R_PPC64_TOC16_LO_DS:
14589         case R_PPC64_PLTGOT16_DS:
14590         case R_PPC64_PLTGOT16_LO_DS:
14591         case R_PPC64_GOT_TPREL16_DS:
14592         case R_PPC64_GOT_TPREL16_LO_DS:
14593         case R_PPC64_GOT_DTPREL16_DS:
14594         case R_PPC64_GOT_DTPREL16_LO_DS:
14595         case R_PPC64_TPREL16_DS:
14596         case R_PPC64_TPREL16_LO_DS:
14597         case R_PPC64_DTPREL16_DS:
14598         case R_PPC64_DTPREL16_LO_DS:
14599           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14600           mask = 3;
14601           /* If this reloc is against an lq insn, then the value must be
14602              a multiple of 16.  This is somewhat of a hack, but the
14603              "correct" way to do this by defining _DQ forms of all the
14604              _DS relocs bloats all reloc switches in this file.  It
14605              doesn't seem to make much sense to use any of these relocs
14606              in data, so testing the insn should be safe.  */
14607           if ((insn & (0x3f << 26)) == (56u << 26))
14608             mask = 15;
14609           if (((relocation + addend) & mask) != 0)
14610             {
14611               info->callbacks->einfo
14612                 (_("%P: %H: error: %s not a multiple of %u\n"),
14613                  input_bfd, input_section, rel->r_offset,
14614                  howto->name,
14615                  mask + 1);
14616               bfd_set_error (bfd_error_bad_value);
14617               ret = FALSE;
14618               continue;
14619             }
14620           break;
14621         }
14622
14623       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14624          because such sections are not SEC_ALLOC and thus ld.so will
14625          not process them.  */
14626       if (unresolved_reloc
14627           && !((input_section->flags & SEC_DEBUGGING) != 0
14628                && h->elf.def_dynamic)
14629           && _bfd_elf_section_offset (output_bfd, info, input_section,
14630                                       rel->r_offset) != (bfd_vma) -1)
14631         {
14632           info->callbacks->einfo
14633             (_("%P: %H: unresolvable %s against `%T'\n"),
14634              input_bfd, input_section, rel->r_offset,
14635              howto->name,
14636              h->elf.root.root.string);
14637           ret = FALSE;
14638         }
14639
14640       /* 16-bit fields in insns mostly have signed values, but a
14641          few insns have 16-bit unsigned values.  Really, we should
14642          have different reloc types.  */
14643       if (howto->complain_on_overflow != complain_overflow_dont
14644           && howto->dst_mask == 0xffff
14645           && (input_section->flags & SEC_CODE) != 0)
14646         {
14647           enum complain_overflow complain = complain_overflow_signed;
14648
14649           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14650           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14651             complain = complain_overflow_bitfield;
14652           else if (howto->rightshift == 0
14653                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14654                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14655                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14656                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14657                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14658                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14659             complain = complain_overflow_unsigned;
14660           if (howto->complain_on_overflow != complain)
14661             {
14662               alt_howto = *howto;
14663               alt_howto.complain_on_overflow = complain;
14664               howto = &alt_howto;
14665             }
14666         }
14667
14668       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14669                                     rel->r_offset, relocation, addend);
14670
14671       if (r != bfd_reloc_ok)
14672         {
14673           char *more_info = NULL;
14674           const char *reloc_name = howto->name;
14675
14676           if (reloc_dest != DEST_NORMAL)
14677             {
14678               more_info = bfd_malloc (strlen (reloc_name) + 8);
14679               if (more_info != NULL)
14680                 {
14681                   strcpy (more_info, reloc_name);
14682                   strcat (more_info, (reloc_dest == DEST_OPD
14683                                       ? " (OPD)" : " (stub)"));
14684                   reloc_name = more_info;
14685                 }
14686             }
14687
14688           if (r == bfd_reloc_overflow)
14689             {
14690               if (warned)
14691                 continue;
14692               if (h != NULL
14693                   && h->elf.root.type == bfd_link_hash_undefweak
14694                   && howto->pc_relative)
14695                 {
14696                   /* Assume this is a call protected by other code that
14697                      detects the symbol is undefined.  If this is the case,
14698                      we can safely ignore the overflow.  If not, the
14699                      program is hosed anyway, and a little warning isn't
14700                      going to help.  */
14701
14702                   continue;
14703                 }
14704
14705               if (!((*info->callbacks->reloc_overflow)
14706                     (info, &h->elf.root, sym_name,
14707                      reloc_name, orig_rel.r_addend,
14708                      input_bfd, input_section, rel->r_offset)))
14709                 return FALSE;
14710             }
14711           else
14712             {
14713               info->callbacks->einfo
14714                 (_("%P: %H: %s against `%T': error %d\n"),
14715                  input_bfd, input_section, rel->r_offset,
14716                  reloc_name, sym_name, (int) r);
14717               ret = FALSE;
14718             }
14719           if (more_info != NULL)
14720             free (more_info);
14721         }
14722     }
14723
14724   /* If we're emitting relocations, then shortly after this function
14725      returns, reloc offsets and addends for this section will be
14726      adjusted.  Worse, reloc symbol indices will be for the output
14727      file rather than the input.  Save a copy of the relocs for
14728      opd_entry_value.  */
14729   if (is_opd && (info->emitrelocations || info->relocatable))
14730     {
14731       bfd_size_type amt;
14732       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14733       rel = bfd_alloc (input_bfd, amt);
14734       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14735       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14736       if (rel == NULL)
14737         return FALSE;
14738       memcpy (rel, relocs, amt);
14739     }
14740   return ret;
14741 }
14742
14743 /* Adjust the value of any local symbols in opd sections.  */
14744
14745 static int
14746 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14747                               const char *name ATTRIBUTE_UNUSED,
14748                               Elf_Internal_Sym *elfsym,
14749                               asection *input_sec,
14750                               struct elf_link_hash_entry *h)
14751 {
14752   struct _opd_sec_data *opd;
14753   long adjust;
14754   bfd_vma value;
14755
14756   if (h != NULL)
14757     return 1;
14758
14759   opd = get_opd_info (input_sec);
14760   if (opd == NULL || opd->adjust == NULL)
14761     return 1;
14762
14763   value = elfsym->st_value - input_sec->output_offset;
14764   if (!info->relocatable)
14765     value -= input_sec->output_section->vma;
14766
14767   adjust = opd->adjust[value / 8];
14768   if (adjust == -1)
14769     return 2;
14770
14771   elfsym->st_value += adjust;
14772   return 1;
14773 }
14774
14775 /* Finish up dynamic symbol handling.  We set the contents of various
14776    dynamic sections here.  */
14777
14778 static bfd_boolean
14779 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14780                                  struct bfd_link_info *info,
14781                                  struct elf_link_hash_entry *h,
14782                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14783 {
14784   struct ppc_link_hash_table *htab;
14785   struct plt_entry *ent;
14786   Elf_Internal_Rela rela;
14787   bfd_byte *loc;
14788
14789   htab = ppc_hash_table (info);
14790   if (htab == NULL)
14791     return FALSE;
14792
14793   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14794     if (ent->plt.offset != (bfd_vma) -1)
14795       {
14796         /* This symbol has an entry in the procedure linkage
14797            table.  Set it up.  */
14798         if (!htab->elf.dynamic_sections_created
14799             || h->dynindx == -1)
14800           {
14801             BFD_ASSERT (h->type == STT_GNU_IFUNC
14802                         && h->def_regular
14803                         && (h->root.type == bfd_link_hash_defined
14804                             || h->root.type == bfd_link_hash_defweak));
14805             rela.r_offset = (htab->elf.iplt->output_section->vma
14806                              + htab->elf.iplt->output_offset
14807                              + ent->plt.offset);
14808             if (htab->opd_abi)
14809               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14810             else
14811               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14812             rela.r_addend = (h->root.u.def.value
14813                              + h->root.u.def.section->output_offset
14814                              + h->root.u.def.section->output_section->vma
14815                              + ent->addend);
14816             loc = (htab->elf.irelplt->contents
14817                    + (htab->elf.irelplt->reloc_count++
14818                       * sizeof (Elf64_External_Rela)));
14819           }
14820         else
14821           {
14822             rela.r_offset = (htab->elf.splt->output_section->vma
14823                              + htab->elf.splt->output_offset
14824                              + ent->plt.offset);
14825             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14826             rela.r_addend = ent->addend;
14827             loc = (htab->elf.srelplt->contents
14828                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14829                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14830           }
14831         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14832
14833         if (!htab->opd_abi)
14834           {
14835             if (!h->def_regular)
14836               {
14837                 /* Mark the symbol as undefined, rather than as
14838                    defined in glink.  Leave the value if there were
14839                    any relocations where pointer equality matters
14840                    (this is a clue for the dynamic linker, to make
14841                    function pointer comparisons work between an
14842                    application and shared library), otherwise set it
14843                    to zero.  */
14844                 sym->st_shndx = SHN_UNDEF;
14845                 if (!h->pointer_equality_needed)
14846                   sym->st_value = 0;
14847                 else if (!h->ref_regular_nonweak)
14848                   {
14849                     /* This breaks function pointer comparisons, but
14850                        that is better than breaking tests for a NULL
14851                        function pointer.  */
14852                     sym->st_value = 0;
14853                   }
14854               }
14855           }
14856       }
14857
14858   if (h->needs_copy)
14859     {
14860       /* This symbol needs a copy reloc.  Set it up.  */
14861
14862       if (h->dynindx == -1
14863           || (h->root.type != bfd_link_hash_defined
14864               && h->root.type != bfd_link_hash_defweak)
14865           || htab->relbss == NULL)
14866         abort ();
14867
14868       rela.r_offset = (h->root.u.def.value
14869                        + h->root.u.def.section->output_section->vma
14870                        + h->root.u.def.section->output_offset);
14871       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14872       rela.r_addend = 0;
14873       loc = htab->relbss->contents;
14874       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14875       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14876     }
14877
14878   return TRUE;
14879 }
14880
14881 /* Used to decide how to sort relocs in an optimal manner for the
14882    dynamic linker, before writing them out.  */
14883
14884 static enum elf_reloc_type_class
14885 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14886                             const asection *rel_sec,
14887                             const Elf_Internal_Rela *rela)
14888 {
14889   enum elf_ppc64_reloc_type r_type;
14890   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14891
14892   if (rel_sec == htab->elf.irelplt)
14893     return reloc_class_ifunc;
14894
14895   r_type = ELF64_R_TYPE (rela->r_info);
14896   switch (r_type)
14897     {
14898     case R_PPC64_RELATIVE:
14899       return reloc_class_relative;
14900     case R_PPC64_JMP_SLOT:
14901       return reloc_class_plt;
14902     case R_PPC64_COPY:
14903       return reloc_class_copy;
14904     default:
14905       return reloc_class_normal;
14906     }
14907 }
14908
14909 /* Finish up the dynamic sections.  */
14910
14911 static bfd_boolean
14912 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14913                                    struct bfd_link_info *info)
14914 {
14915   struct ppc_link_hash_table *htab;
14916   bfd *dynobj;
14917   asection *sdyn;
14918
14919   htab = ppc_hash_table (info);
14920   if (htab == NULL)
14921     return FALSE;
14922
14923   dynobj = htab->elf.dynobj;
14924   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14925
14926   if (htab->elf.dynamic_sections_created)
14927     {
14928       Elf64_External_Dyn *dyncon, *dynconend;
14929
14930       if (sdyn == NULL || htab->elf.sgot == NULL)
14931         abort ();
14932
14933       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14934       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14935       for (; dyncon < dynconend; dyncon++)
14936         {
14937           Elf_Internal_Dyn dyn;
14938           asection *s;
14939
14940           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14941
14942           switch (dyn.d_tag)
14943             {
14944             default:
14945               continue;
14946
14947             case DT_PPC64_GLINK:
14948               s = htab->glink;
14949               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14950               /* We stupidly defined DT_PPC64_GLINK to be the start
14951                  of glink rather than the first entry point, which is
14952                  what ld.so needs, and now have a bigger stub to
14953                  support automatic multiple TOCs.  */
14954               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14955               break;
14956
14957             case DT_PPC64_OPD:
14958               s = bfd_get_section_by_name (output_bfd, ".opd");
14959               if (s == NULL)
14960                 continue;
14961               dyn.d_un.d_ptr = s->vma;
14962               break;
14963
14964             case DT_PPC64_OPT:
14965               if (htab->do_multi_toc && htab->multi_toc_needed)
14966                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14967               break;
14968
14969             case DT_PPC64_OPDSZ:
14970               s = bfd_get_section_by_name (output_bfd, ".opd");
14971               if (s == NULL)
14972                 continue;
14973               dyn.d_un.d_val = s->size;
14974               break;
14975
14976             case DT_PLTGOT:
14977               s = htab->elf.splt;
14978               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14979               break;
14980
14981             case DT_JMPREL:
14982               s = htab->elf.srelplt;
14983               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14984               break;
14985
14986             case DT_PLTRELSZ:
14987               dyn.d_un.d_val = htab->elf.srelplt->size;
14988               break;
14989
14990             case DT_RELASZ:
14991               /* Don't count procedure linkage table relocs in the
14992                  overall reloc count.  */
14993               s = htab->elf.srelplt;
14994               if (s == NULL)
14995                 continue;
14996               dyn.d_un.d_val -= s->size;
14997               break;
14998
14999             case DT_RELA:
15000               /* We may not be using the standard ELF linker script.
15001                  If .rela.plt is the first .rela section, we adjust
15002                  DT_RELA to not include it.  */
15003               s = htab->elf.srelplt;
15004               if (s == NULL)
15005                 continue;
15006               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15007                 continue;
15008               dyn.d_un.d_ptr += s->size;
15009               break;
15010             }
15011
15012           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15013         }
15014     }
15015
15016   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15017     {
15018       /* Fill in the first entry in the global offset table.
15019          We use it to hold the link-time TOCbase.  */
15020       bfd_put_64 (output_bfd,
15021                   elf_gp (output_bfd) + TOC_BASE_OFF,
15022                   htab->elf.sgot->contents);
15023
15024       /* Set .got entry size.  */
15025       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15026     }
15027
15028   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15029     {
15030       /* Set .plt entry size.  */
15031       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15032         = PLT_ENTRY_SIZE (htab);
15033     }
15034
15035   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15036      brlt ourselves if emitrelocations.  */
15037   if (htab->brlt != NULL
15038       && htab->brlt->reloc_count != 0
15039       && !_bfd_elf_link_output_relocs (output_bfd,
15040                                        htab->brlt,
15041                                        elf_section_data (htab->brlt)->rela.hdr,
15042                                        elf_section_data (htab->brlt)->relocs,
15043                                        NULL))
15044     return FALSE;
15045
15046   if (htab->glink != NULL
15047       && htab->glink->reloc_count != 0
15048       && !_bfd_elf_link_output_relocs (output_bfd,
15049                                        htab->glink,
15050                                        elf_section_data (htab->glink)->rela.hdr,
15051                                        elf_section_data (htab->glink)->relocs,
15052                                        NULL))
15053     return FALSE;
15054
15055
15056   if (htab->glink_eh_frame != NULL
15057       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15058       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15059                                            htab->glink_eh_frame,
15060                                            htab->glink_eh_frame->contents))
15061     return FALSE;
15062
15063   /* We need to handle writing out multiple GOT sections ourselves,
15064      since we didn't add them to DYNOBJ.  We know dynobj is the first
15065      bfd.  */
15066   while ((dynobj = dynobj->link.next) != NULL)
15067     {
15068       asection *s;
15069
15070       if (!is_ppc64_elf (dynobj))
15071         continue;
15072
15073       s = ppc64_elf_tdata (dynobj)->got;
15074       if (s != NULL
15075           && s->size != 0
15076           && s->output_section != bfd_abs_section_ptr
15077           && !bfd_set_section_contents (output_bfd, s->output_section,
15078                                         s->contents, s->output_offset,
15079                                         s->size))
15080         return FALSE;
15081       s = ppc64_elf_tdata (dynobj)->relgot;
15082       if (s != NULL
15083           && s->size != 0
15084           && s->output_section != bfd_abs_section_ptr
15085           && !bfd_set_section_contents (output_bfd, s->output_section,
15086                                         s->contents, s->output_offset,
15087                                         s->size))
15088         return FALSE;
15089     }
15090
15091   return TRUE;
15092 }
15093
15094 #include "elf64-target.h"
15095
15096 /* FreeBSD support */
15097
15098 #undef  TARGET_LITTLE_SYM
15099 #undef  TARGET_LITTLE_NAME
15100
15101 #undef  TARGET_BIG_SYM
15102 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15103 #undef  TARGET_BIG_NAME
15104 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15105
15106 #undef  ELF_OSABI
15107 #define ELF_OSABI       ELFOSABI_FREEBSD
15108
15109 #undef  elf64_bed
15110 #define elf64_bed       elf64_powerpc_fbsd_bed
15111
15112 #include "elf64-target.h"
15113