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       bfd_elf64_powerpcle_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  99 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 109 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 110 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 111 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 112 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 113 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 114 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 115 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 116 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 117 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 118 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 119 #define elf_backend_special_sections          ppc64_elf_special_sections
 120 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 121
 122 /* The name of the dynamic interpreter.  This is put in the .interp
 123    section.  */
 124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 125
 126 /* The size in bytes of an entry in the procedure linkage table.  */
 127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 128
 129 /* The initial size of the plt reserved for the dynamic linker.  */
 130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 131
 132 /* Offsets to some stack save slots.  */
 133 #define STK_LR 16
 134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 135 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 136    CR save slot.  Used only by optimised __tls_get_addr call stub,
 137    relying on __tls_get_addr_opt not saving CR..  */
 138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 139
 140 /* TOC base pointers offset from start of TOC.  */
 141 #define TOC_BASE_OFF    0x8000
 142
 143 /* Offset of tp and dtp pointers from start of TLS block.  */
 144 #define TP_OFFSET       0x7000
 145 #define DTP_OFFSET      0x8000
 146
 147 /* .plt call stub instructions.  The normal stub is like this, but
 148    sometimes the .plt entry crosses a 64k boundary and we need to
 149    insert an addi to adjust r11.  */
 150 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 151 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 152 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 153 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 154 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 155 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 156 #define BCTR            0x4e800420      /* bctr                      */
 157
 158 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 159 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 160 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 161
 162 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 163 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 164 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 165 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 166 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 167 #define BNECTR          0x4ca20420      /* bnectr+               */
 168 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 169
 170 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 171 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 172 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 173
 174 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 175
 176 #define ADDIS_R12_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_bitfield, /* 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_bitfield, /* 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_bitfield, /* 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          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 636          complain_overflow_signed, /* complain_on_overflow */
 637          bfd_elf_generic_reloc, /* special_function */
 638          "R_PPC64_REL32",       /* name */
 639          FALSE,                 /* partial_inplace */
 640          0,                     /* src_mask */
 641          0xffffffff,            /* dst_mask */
 642          TRUE),                 /* pcrel_offset */
 643
 644   /* 32-bit relocation to the symbol's procedure linkage table.  */
 645   HOWTO (R_PPC64_PLT32,         /* type */
 646          0,                     /* rightshift */
 647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          32,                    /* bitsize */
 649          FALSE,                 /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_bitfield, /* complain_on_overflow */
 652          ppc64_elf_unhandled_reloc, /* special_function */
 653          "R_PPC64_PLT32",       /* name */
 654          FALSE,                 /* partial_inplace */
 655          0,                     /* src_mask */
 656          0xffffffff,            /* dst_mask */
 657          FALSE),                /* pcrel_offset */
 658
 659   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 660      FIXME: R_PPC64_PLTREL32 not supported.  */
 661   HOWTO (R_PPC64_PLTREL32,      /* type */
 662          0,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          32,                    /* bitsize */
 665          TRUE,                  /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_signed, /* complain_on_overflow */
 668          bfd_elf_generic_reloc, /* special_function */
 669          "R_PPC64_PLTREL32",    /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffffffff,            /* dst_mask */
 673          TRUE),                 /* pcrel_offset */
 674
 675   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 676      the symbol.  */
 677   HOWTO (R_PPC64_PLT16_LO,      /* type */
 678          0,                     /* rightshift */
 679          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          16,                    /* bitsize */
 681          FALSE,                 /* pc_relative */
 682          0,                     /* bitpos */
 683          complain_overflow_dont, /* complain_on_overflow */
 684          ppc64_elf_unhandled_reloc, /* special_function */
 685          "R_PPC64_PLT16_LO",    /* name */
 686          FALSE,                 /* partial_inplace */
 687          0,                     /* src_mask */
 688          0xffff,                /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 692      the symbol.  */
 693   HOWTO (R_PPC64_PLT16_HI,      /* type */
 694          16,                    /* rightshift */
 695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 696          16,                    /* bitsize */
 697          FALSE,                 /* pc_relative */
 698          0,                     /* bitpos */
 699          complain_overflow_signed, /* complain_on_overflow */
 700          ppc64_elf_unhandled_reloc, /* special_function */
 701          "R_PPC64_PLT16_HI",    /* name */
 702          FALSE,                 /* partial_inplace */
 703          0,                     /* src_mask */
 704          0xffff,                /* dst_mask */
 705          FALSE),                /* pcrel_offset */
 706
 707   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 708      the symbol.  */
 709   HOWTO (R_PPC64_PLT16_HA,      /* type */
 710          16,                    /* rightshift */
 711          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 712          16,                    /* bitsize */
 713          FALSE,                 /* pc_relative */
 714          0,                     /* bitpos */
 715          complain_overflow_signed, /* complain_on_overflow */
 716          ppc64_elf_unhandled_reloc, /* special_function */
 717          "R_PPC64_PLT16_HA",    /* name */
 718          FALSE,                 /* partial_inplace */
 719          0,                     /* src_mask */
 720          0xffff,                /* dst_mask */
 721          FALSE),                /* pcrel_offset */
 722
 723   /* 16-bit section relative relocation.  */
 724   HOWTO (R_PPC64_SECTOFF,       /* type */
 725          0,                     /* rightshift */
 726          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 727          16,                    /* bitsize */
 728          FALSE,                 /* pc_relative */
 729          0,                     /* bitpos */
 730          complain_overflow_bitfield, /* complain_on_overflow */
 731          ppc64_elf_sectoff_reloc, /* special_function */
 732          "R_PPC64_SECTOFF",     /* name */
 733          FALSE,                 /* partial_inplace */
 734          0,                     /* src_mask */
 735          0xffff,                /* dst_mask */
 736          FALSE),                /* pcrel_offset */
 737
 738   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 739   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 740          0,                     /* rightshift */
 741          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 742          16,                    /* bitsize */
 743          FALSE,                 /* pc_relative */
 744          0,                     /* bitpos */
 745          complain_overflow_dont, /* complain_on_overflow */
 746          ppc64_elf_sectoff_reloc, /* special_function */
 747          "R_PPC64_SECTOFF_LO",  /* name */
 748          FALSE,                 /* partial_inplace */
 749          0,                     /* src_mask */
 750          0xffff,                /* dst_mask */
 751          FALSE),                /* pcrel_offset */
 752
 753   /* 16-bit upper half section relative relocation.  */
 754   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 755          16,                    /* rightshift */
 756          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          16,                    /* bitsize */
 758          FALSE,                 /* pc_relative */
 759          0,                     /* bitpos */
 760          complain_overflow_signed, /* complain_on_overflow */
 761          ppc64_elf_sectoff_reloc, /* special_function */
 762          "R_PPC64_SECTOFF_HI",  /* name */
 763          FALSE,                 /* partial_inplace */
 764          0,                     /* src_mask */
 765          0xffff,                /* dst_mask */
 766          FALSE),                /* pcrel_offset */
 767
 768   /* 16-bit upper half adjusted section relative relocation.  */
 769   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 770          16,                    /* rightshift */
 771          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 772          16,                    /* bitsize */
 773          FALSE,                 /* pc_relative */
 774          0,                     /* bitpos */
 775          complain_overflow_signed, /* complain_on_overflow */
 776          ppc64_elf_sectoff_ha_reloc, /* special_function */
 777          "R_PPC64_SECTOFF_HA",  /* name */
 778          FALSE,                 /* partial_inplace */
 779          0,                     /* src_mask */
 780          0xffff,                /* dst_mask */
 781          FALSE),                /* pcrel_offset */
 782
 783   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 784   HOWTO (R_PPC64_REL30,         /* type */
 785          2,                     /* rightshift */
 786          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 787          30,                    /* bitsize */
 788          TRUE,                  /* pc_relative */
 789          0,                     /* bitpos */
 790          complain_overflow_dont, /* complain_on_overflow */
 791          bfd_elf_generic_reloc, /* special_function */
 792          "R_PPC64_REL30",       /* name */
 793          FALSE,                 /* partial_inplace */
 794          0,                     /* src_mask */
 795          0xfffffffc,            /* dst_mask */
 796          TRUE),                 /* pcrel_offset */
 797
 798   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 799
 800   /* A standard 64-bit relocation.  */
 801   HOWTO (R_PPC64_ADDR64,        /* type */
 802          0,                     /* rightshift */
 803          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 804          64,                    /* bitsize */
 805          FALSE,                 /* pc_relative */
 806          0,                     /* bitpos */
 807          complain_overflow_dont, /* complain_on_overflow */
 808          bfd_elf_generic_reloc, /* special_function */
 809          "R_PPC64_ADDR64",      /* name */
 810          FALSE,                 /* partial_inplace */
 811          0,                     /* src_mask */
 812          ONES (64),             /* dst_mask */
 813          FALSE),                /* pcrel_offset */
 814
 815   /* The bits 32-47 of an address.  */
 816   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 817          32,                    /* rightshift */
 818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          16,                    /* bitsize */
 820          FALSE,                 /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_dont, /* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_PPC64_ADDR16_HIGHER", /* name */
 825          FALSE,                 /* partial_inplace */
 826          0,                     /* src_mask */
 827          0xffff,                /* dst_mask */
 828          FALSE),                /* pcrel_offset */
 829
 830   /* The bits 32-47 of an address, plus 1 if the contents of the low
 831      16 bits, treated as a signed number, is negative.  */
 832   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 833          32,                    /* rightshift */
 834          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 835          16,                    /* bitsize */
 836          FALSE,                 /* pc_relative */
 837          0,                     /* bitpos */
 838          complain_overflow_dont, /* complain_on_overflow */
 839          ppc64_elf_ha_reloc,    /* special_function */
 840          "R_PPC64_ADDR16_HIGHERA", /* name */
 841          FALSE,                 /* partial_inplace */
 842          0,                     /* src_mask */
 843          0xffff,                /* dst_mask */
 844          FALSE),                /* pcrel_offset */
 845
 846   /* The bits 48-63 of an address.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 848          48,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_PPC64_ADDR16_HIGHEST", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* The bits 48-63 of an address, plus 1 if the contents of the low
 862      16 bits, treated as a signed number, is negative.  */
 863   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 864          48,                    /* rightshift */
 865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          16,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont, /* complain_on_overflow */
 870          ppc64_elf_ha_reloc,    /* special_function */
 871          "R_PPC64_ADDR16_HIGHESTA", /* name */
 872          FALSE,                 /* partial_inplace */
 873          0,                     /* src_mask */
 874          0xffff,                /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   /* Like ADDR64, but may be unaligned.  */
 878   HOWTO (R_PPC64_UADDR64,       /* type */
 879          0,                     /* rightshift */
 880          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 881          64,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_dont, /* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_PPC64_UADDR64",     /* name */
 887          FALSE,                 /* partial_inplace */
 888          0,                     /* src_mask */
 889          ONES (64),             /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   /* 64-bit relative relocation.  */
 893   HOWTO (R_PPC64_REL64,         /* type */
 894          0,                     /* rightshift */
 895          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 896          64,                    /* bitsize */
 897          TRUE,                  /* pc_relative */
 898          0,                     /* bitpos */
 899          complain_overflow_dont, /* complain_on_overflow */
 900          bfd_elf_generic_reloc, /* special_function */
 901          "R_PPC64_REL64",       /* name */
 902          FALSE,                 /* partial_inplace */
 903          0,                     /* src_mask */
 904          ONES (64),             /* dst_mask */
 905          TRUE),                 /* pcrel_offset */
 906
 907   /* 64-bit relocation to the symbol's procedure linkage table.  */
 908   HOWTO (R_PPC64_PLT64,         /* type */
 909          0,                     /* rightshift */
 910          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 911          64,                    /* bitsize */
 912          FALSE,                 /* pc_relative */
 913          0,                     /* bitpos */
 914          complain_overflow_dont, /* complain_on_overflow */
 915          ppc64_elf_unhandled_reloc, /* special_function */
 916          "R_PPC64_PLT64",       /* name */
 917          FALSE,                 /* partial_inplace */
 918          0,                     /* src_mask */
 919          ONES (64),             /* dst_mask */
 920          FALSE),                /* pcrel_offset */
 921
 922   /* 64-bit PC relative relocation to the symbol's procedure linkage
 923      table.  */
 924   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 925   HOWTO (R_PPC64_PLTREL64,      /* type */
 926          0,                     /* rightshift */
 927          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 928          64,                    /* bitsize */
 929          TRUE,                  /* pc_relative */
 930          0,                     /* bitpos */
 931          complain_overflow_dont, /* complain_on_overflow */
 932          ppc64_elf_unhandled_reloc, /* special_function */
 933          "R_PPC64_PLTREL64",    /* name */
 934          FALSE,                 /* partial_inplace */
 935          0,                     /* src_mask */
 936          ONES (64),             /* dst_mask */
 937          TRUE),                 /* pcrel_offset */
 938
 939   /* 16 bit TOC-relative relocation.  */
 940
 941   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 942   HOWTO (R_PPC64_TOC16,         /* type */
 943          0,                     /* rightshift */
 944          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 945          16,                    /* bitsize */
 946          FALSE,                 /* pc_relative */
 947          0,                     /* bitpos */
 948          complain_overflow_signed, /* complain_on_overflow */
 949          ppc64_elf_toc_reloc,   /* special_function */
 950          "R_PPC64_TOC16",       /* name */
 951          FALSE,                 /* partial_inplace */
 952          0,                     /* src_mask */
 953          0xffff,                /* dst_mask */
 954          FALSE),                /* pcrel_offset */
 955
 956   /* 16 bit TOC-relative relocation without overflow.  */
 957
 958   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 959   HOWTO (R_PPC64_TOC16_LO,      /* type */
 960          0,                     /* rightshift */
 961          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 962          16,                    /* bitsize */
 963          FALSE,                 /* pc_relative */
 964          0,                     /* bitpos */
 965          complain_overflow_dont, /* complain_on_overflow */
 966          ppc64_elf_toc_reloc,   /* special_function */
 967          "R_PPC64_TOC16_LO",    /* name */
 968          FALSE,                 /* partial_inplace */
 969          0,                     /* src_mask */
 970          0xffff,                /* dst_mask */
 971          FALSE),                /* pcrel_offset */
 972
 973   /* 16 bit TOC-relative relocation, high 16 bits.  */
 974
 975   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 976   HOWTO (R_PPC64_TOC16_HI,      /* type */
 977          16,                    /* rightshift */
 978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 979          16,                    /* bitsize */
 980          FALSE,                 /* pc_relative */
 981          0,                     /* bitpos */
 982          complain_overflow_signed, /* complain_on_overflow */
 983          ppc64_elf_toc_reloc,   /* special_function */
 984          "R_PPC64_TOC16_HI",    /* name */
 985          FALSE,                 /* partial_inplace */
 986          0,                     /* src_mask */
 987          0xffff,                /* dst_mask */
 988          FALSE),                /* pcrel_offset */
 989
 990   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 991      contents of the low 16 bits, treated as a signed number, is
 992      negative.  */
 993
 994   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 995   HOWTO (R_PPC64_TOC16_HA,      /* type */
 996          16,                    /* rightshift */
 997          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 998          16,                    /* bitsize */
 999          FALSE,                 /* pc_relative */
1000          0,                     /* bitpos */
1001          complain_overflow_signed, /* complain_on_overflow */
1002          ppc64_elf_toc_ha_reloc, /* special_function */
1003          "R_PPC64_TOC16_HA",    /* name */
1004          FALSE,                 /* partial_inplace */
1005          0,                     /* src_mask */
1006          0xffff,                /* dst_mask */
1007          FALSE),                /* pcrel_offset */
1008
1009   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1010
1011   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1012   HOWTO (R_PPC64_TOC,           /* type */
1013          0,                     /* rightshift */
1014          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1015          64,                    /* bitsize */
1016          FALSE,                 /* pc_relative */
1017          0,                     /* bitpos */
1018          complain_overflow_bitfield, /* complain_on_overflow */
1019          ppc64_elf_toc64_reloc, /* special_function */
1020          "R_PPC64_TOC",         /* name */
1021          FALSE,                 /* partial_inplace */
1022          0,                     /* src_mask */
1023          ONES (64),             /* dst_mask */
1024          FALSE),                /* pcrel_offset */
1025
1026   /* Like R_PPC64_GOT16, but also informs the link editor that the
1027      value to relocate may (!) refer to a PLT entry which the link
1028      editor (a) may replace with the symbol value.  If the link editor
1029      is unable to fully resolve the symbol, it may (b) create a PLT
1030      entry and store the address to the new PLT entry in the GOT.
1031      This permits lazy resolution of function symbols at run time.
1032      The link editor may also skip all of this and just (c) emit a
1033      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1034   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1035     HOWTO (R_PPC64_PLTGOT16,    /* type */
1036          0,                     /* rightshift */
1037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          16,                    /* bitsize */
1039          FALSE,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_signed, /* complain_on_overflow */
1042          ppc64_elf_unhandled_reloc, /* special_function */
1043          "R_PPC64_PLTGOT16",    /* name */
1044          FALSE,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          0xffff,                /* dst_mask */
1047          FALSE),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1050   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1051   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1052          0,                     /* rightshift */
1053          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1054          16,                    /* bitsize */
1055          FALSE,                 /* pc_relative */
1056          0,                     /* bitpos */
1057          complain_overflow_dont, /* complain_on_overflow */
1058          ppc64_elf_unhandled_reloc, /* special_function */
1059          "R_PPC64_PLTGOT16_LO", /* name */
1060          FALSE,                 /* partial_inplace */
1061          0,                     /* src_mask */
1062          0xffff,                /* dst_mask */
1063          FALSE),                /* pcrel_offset */
1064
1065   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1066   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1067   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1068          16,                    /* rightshift */
1069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1070          16,                    /* bitsize */
1071          FALSE,                 /* pc_relative */
1072          0,                     /* bitpos */
1073          complain_overflow_signed, /* complain_on_overflow */
1074          ppc64_elf_unhandled_reloc, /* special_function */
1075          "R_PPC64_PLTGOT16_HI", /* name */
1076          FALSE,                 /* partial_inplace */
1077          0,                     /* src_mask */
1078          0xffff,                /* dst_mask */
1079          FALSE),                /* pcrel_offset */
1080
1081   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1082      1 if the contents of the low 16 bits, treated as a signed number,
1083      is negative.  */
1084   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1085   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1086          16,                    /* rightshift */
1087          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1088          16,                    /* bitsize */
1089          FALSE,                 /* pc_relative */
1090          0,                     /* bitpos */
1091          complain_overflow_signed, /* complain_on_overflow */
1092          ppc64_elf_unhandled_reloc, /* special_function */
1093          "R_PPC64_PLTGOT16_HA", /* name */
1094          FALSE,                 /* partial_inplace */
1095          0,                     /* src_mask */
1096          0xffff,                /* dst_mask */
1097          FALSE),                /* pcrel_offset */
1098
1099   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1100   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1101          0,                     /* rightshift */
1102          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1103          16,                    /* bitsize */
1104          FALSE,                 /* pc_relative */
1105          0,                     /* bitpos */
1106          complain_overflow_bitfield, /* complain_on_overflow */
1107          bfd_elf_generic_reloc, /* special_function */
1108          "R_PPC64_ADDR16_DS",   /* name */
1109          FALSE,                 /* partial_inplace */
1110          0,                     /* src_mask */
1111          0xfffc,                /* dst_mask */
1112          FALSE),                /* pcrel_offset */
1113
1114   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1115   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1116          0,                     /* rightshift */
1117          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1118          16,                    /* bitsize */
1119          FALSE,                 /* pc_relative */
1120          0,                     /* bitpos */
1121          complain_overflow_dont,/* complain_on_overflow */
1122          bfd_elf_generic_reloc, /* special_function */
1123          "R_PPC64_ADDR16_LO_DS",/* name */
1124          FALSE,                 /* partial_inplace */
1125          0,                     /* src_mask */
1126          0xfffc,                /* dst_mask */
1127          FALSE),                /* pcrel_offset */
1128
1129   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1130   HOWTO (R_PPC64_GOT16_DS,      /* type */
1131          0,                     /* rightshift */
1132          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1133          16,                    /* bitsize */
1134          FALSE,                 /* pc_relative */
1135          0,                     /* bitpos */
1136          complain_overflow_signed, /* complain_on_overflow */
1137          ppc64_elf_unhandled_reloc, /* special_function */
1138          "R_PPC64_GOT16_DS",    /* name */
1139          FALSE,                 /* partial_inplace */
1140          0,                     /* src_mask */
1141          0xfffc,                /* dst_mask */
1142          FALSE),                /* pcrel_offset */
1143
1144   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1145   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1146          0,                     /* rightshift */
1147          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          16,                    /* bitsize */
1149          FALSE,                 /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont, /* complain_on_overflow */
1152          ppc64_elf_unhandled_reloc, /* special_function */
1153          "R_PPC64_GOT16_LO_DS", /* name */
1154          FALSE,                 /* partial_inplace */
1155          0,                     /* src_mask */
1156          0xfffc,                /* dst_mask */
1157          FALSE),                /* pcrel_offset */
1158
1159   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1160   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1161          0,                     /* rightshift */
1162          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1163          16,                    /* bitsize */
1164          FALSE,                 /* pc_relative */
1165          0,                     /* bitpos */
1166          complain_overflow_dont, /* complain_on_overflow */
1167          ppc64_elf_unhandled_reloc, /* special_function */
1168          "R_PPC64_PLT16_LO_DS", /* name */
1169          FALSE,                 /* partial_inplace */
1170          0,                     /* src_mask */
1171          0xfffc,                /* dst_mask */
1172          FALSE),                /* pcrel_offset */
1173
1174   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1175   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1176          0,                     /* rightshift */
1177          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1178          16,                    /* bitsize */
1179          FALSE,                 /* pc_relative */
1180          0,                     /* bitpos */
1181          complain_overflow_bitfield, /* complain_on_overflow */
1182          ppc64_elf_sectoff_reloc, /* special_function */
1183          "R_PPC64_SECTOFF_DS",  /* name */
1184          FALSE,                 /* partial_inplace */
1185          0,                     /* src_mask */
1186          0xfffc,                /* dst_mask */
1187          FALSE),                /* pcrel_offset */
1188
1189   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1190   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1191          0,                     /* rightshift */
1192          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1193          16,                    /* bitsize */
1194          FALSE,                 /* pc_relative */
1195          0,                     /* bitpos */
1196          complain_overflow_dont, /* complain_on_overflow */
1197          ppc64_elf_sectoff_reloc, /* special_function */
1198          "R_PPC64_SECTOFF_LO_DS",/* name */
1199          FALSE,                 /* partial_inplace */
1200          0,                     /* src_mask */
1201          0xfffc,                /* dst_mask */
1202          FALSE),                /* pcrel_offset */
1203
1204   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1205   HOWTO (R_PPC64_TOC16_DS,      /* type */
1206          0,                     /* rightshift */
1207          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1208          16,                    /* bitsize */
1209          FALSE,                 /* pc_relative */
1210          0,                     /* bitpos */
1211          complain_overflow_signed, /* complain_on_overflow */
1212          ppc64_elf_toc_reloc,   /* special_function */
1213          "R_PPC64_TOC16_DS",    /* name */
1214          FALSE,                 /* partial_inplace */
1215          0,                     /* src_mask */
1216          0xfffc,                /* dst_mask */
1217          FALSE),                /* pcrel_offset */
1218
1219   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1220   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1221          0,                     /* rightshift */
1222          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1223          16,                    /* bitsize */
1224          FALSE,                 /* pc_relative */
1225          0,                     /* bitpos */
1226          complain_overflow_dont, /* complain_on_overflow */
1227          ppc64_elf_toc_reloc,   /* special_function */
1228          "R_PPC64_TOC16_LO_DS", /* name */
1229          FALSE,                 /* partial_inplace */
1230          0,                     /* src_mask */
1231          0xfffc,                /* dst_mask */
1232          FALSE),                /* pcrel_offset */
1233
1234   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1235   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1236   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_signed, /* complain_on_overflow */
1243          ppc64_elf_unhandled_reloc, /* special_function */
1244          "R_PPC64_PLTGOT16_DS", /* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1251   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1252   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1253          0,                     /* rightshift */
1254          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1255          16,                    /* bitsize */
1256          FALSE,                 /* pc_relative */
1257          0,                     /* bitpos */
1258          complain_overflow_dont, /* complain_on_overflow */
1259          ppc64_elf_unhandled_reloc, /* special_function */
1260          "R_PPC64_PLTGOT16_LO_DS",/* name */
1261          FALSE,                 /* partial_inplace */
1262          0,                     /* src_mask */
1263          0xfffc,                /* dst_mask */
1264          FALSE),                /* pcrel_offset */
1265
1266   /* Marker relocs for TLS.  */
1267   HOWTO (R_PPC64_TLS,
1268          0,                     /* rightshift */
1269          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1270          32,                    /* bitsize */
1271          FALSE,                 /* pc_relative */
1272          0,                     /* bitpos */
1273          complain_overflow_dont, /* complain_on_overflow */
1274          bfd_elf_generic_reloc, /* special_function */
1275          "R_PPC64_TLS",         /* name */
1276          FALSE,                 /* partial_inplace */
1277          0,                     /* src_mask */
1278          0,                     /* dst_mask */
1279          FALSE),                /* pcrel_offset */
1280
1281   HOWTO (R_PPC64_TLSGD,
1282          0,                     /* rightshift */
1283          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1284          32,                    /* bitsize */
1285          FALSE,                 /* pc_relative */
1286          0,                     /* bitpos */
1287          complain_overflow_dont, /* complain_on_overflow */
1288          bfd_elf_generic_reloc, /* special_function */
1289          "R_PPC64_TLSGD",       /* name */
1290          FALSE,                 /* partial_inplace */
1291          0,                     /* src_mask */
1292          0,                     /* dst_mask */
1293          FALSE),                /* pcrel_offset */
1294
1295   HOWTO (R_PPC64_TLSLD,
1296          0,                     /* rightshift */
1297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1298          32,                    /* bitsize */
1299          FALSE,                 /* pc_relative */
1300          0,                     /* bitpos */
1301          complain_overflow_dont, /* complain_on_overflow */
1302          bfd_elf_generic_reloc, /* special_function */
1303          "R_PPC64_TLSLD",       /* name */
1304          FALSE,                 /* partial_inplace */
1305          0,                     /* src_mask */
1306          0,                     /* dst_mask */
1307          FALSE),                /* pcrel_offset */
1308
1309   HOWTO (R_PPC64_TOCSAVE,
1310          0,                     /* rightshift */
1311          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1312          32,                    /* bitsize */
1313          FALSE,                 /* pc_relative */
1314          0,                     /* bitpos */
1315          complain_overflow_dont, /* complain_on_overflow */
1316          bfd_elf_generic_reloc, /* special_function */
1317          "R_PPC64_TOCSAVE",     /* name */
1318          FALSE,                 /* partial_inplace */
1319          0,                     /* src_mask */
1320          0,                     /* dst_mask */
1321          FALSE),                /* pcrel_offset */
1322
1323   /* Computes the load module index of the load module that contains the
1324      definition of its TLS sym.  */
1325   HOWTO (R_PPC64_DTPMOD64,
1326          0,                     /* rightshift */
1327          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1328          64,                    /* bitsize */
1329          FALSE,                 /* pc_relative */
1330          0,                     /* bitpos */
1331          complain_overflow_dont, /* complain_on_overflow */
1332          ppc64_elf_unhandled_reloc, /* special_function */
1333          "R_PPC64_DTPMOD64",    /* name */
1334          FALSE,                 /* partial_inplace */
1335          0,                     /* src_mask */
1336          ONES (64),             /* dst_mask */
1337          FALSE),                /* pcrel_offset */
1338
1339   /* Computes a dtv-relative displacement, the difference between the value
1340      of sym+add and the base address of the thread-local storage block that
1341      contains the definition of sym, minus 0x8000.  */
1342   HOWTO (R_PPC64_DTPREL64,
1343          0,                     /* rightshift */
1344          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1345          64,                    /* bitsize */
1346          FALSE,                 /* pc_relative */
1347          0,                     /* bitpos */
1348          complain_overflow_dont, /* complain_on_overflow */
1349          ppc64_elf_unhandled_reloc, /* special_function */
1350          "R_PPC64_DTPREL64",    /* name */
1351          FALSE,                 /* partial_inplace */
1352          0,                     /* src_mask */
1353          ONES (64),             /* dst_mask */
1354          FALSE),                /* pcrel_offset */
1355
1356   /* A 16 bit dtprel reloc.  */
1357   HOWTO (R_PPC64_DTPREL16,
1358          0,                     /* rightshift */
1359          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1360          16,                    /* bitsize */
1361          FALSE,                 /* pc_relative */
1362          0,                     /* bitpos */
1363          complain_overflow_signed, /* complain_on_overflow */
1364          ppc64_elf_unhandled_reloc, /* special_function */
1365          "R_PPC64_DTPREL16",    /* name */
1366          FALSE,                 /* partial_inplace */
1367          0,                     /* src_mask */
1368          0xffff,                /* dst_mask */
1369          FALSE),                /* pcrel_offset */
1370
1371   /* Like DTPREL16, but no overflow.  */
1372   HOWTO (R_PPC64_DTPREL16_LO,
1373          0,                     /* rightshift */
1374          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1375          16,                    /* bitsize */
1376          FALSE,                 /* pc_relative */
1377          0,                     /* bitpos */
1378          complain_overflow_dont, /* complain_on_overflow */
1379          ppc64_elf_unhandled_reloc, /* special_function */
1380          "R_PPC64_DTPREL16_LO", /* name */
1381          FALSE,                 /* partial_inplace */
1382          0,                     /* src_mask */
1383          0xffff,                /* dst_mask */
1384          FALSE),                /* pcrel_offset */
1385
1386   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1387   HOWTO (R_PPC64_DTPREL16_HI,
1388          16,                    /* rightshift */
1389          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          16,                    /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_signed, /* complain_on_overflow */
1394          ppc64_elf_unhandled_reloc, /* special_function */
1395          "R_PPC64_DTPREL16_HI", /* name */
1396          FALSE,                 /* partial_inplace */
1397          0,                     /* src_mask */
1398          0xffff,                /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1402   HOWTO (R_PPC64_DTPREL16_HA,
1403          16,                    /* rightshift */
1404          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          16,                    /* bitsize */
1406          FALSE,                 /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_signed, /* complain_on_overflow */
1409          ppc64_elf_unhandled_reloc, /* special_function */
1410          "R_PPC64_DTPREL16_HA", /* name */
1411          FALSE,                 /* partial_inplace */
1412          0,                     /* src_mask */
1413          0xffff,                /* dst_mask */
1414          FALSE),                /* pcrel_offset */
1415
1416   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1417   HOWTO (R_PPC64_DTPREL16_HIGHER,
1418          32,                    /* rightshift */
1419          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1420          16,                    /* bitsize */
1421          FALSE,                 /* pc_relative */
1422          0,                     /* bitpos */
1423          complain_overflow_dont, /* complain_on_overflow */
1424          ppc64_elf_unhandled_reloc, /* special_function */
1425          "R_PPC64_DTPREL16_HIGHER", /* name */
1426          FALSE,                 /* partial_inplace */
1427          0,                     /* src_mask */
1428          0xffff,                /* dst_mask */
1429          FALSE),                /* pcrel_offset */
1430
1431   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1432   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1433          32,                    /* rightshift */
1434          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1435          16,                    /* bitsize */
1436          FALSE,                 /* pc_relative */
1437          0,                     /* bitpos */
1438          complain_overflow_dont, /* complain_on_overflow */
1439          ppc64_elf_unhandled_reloc, /* special_function */
1440          "R_PPC64_DTPREL16_HIGHERA", /* name */
1441          FALSE,                 /* partial_inplace */
1442          0,                     /* src_mask */
1443          0xffff,                /* dst_mask */
1444          FALSE),                /* pcrel_offset */
1445
1446   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1447   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1448          48,                    /* rightshift */
1449          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1450          16,                    /* bitsize */
1451          FALSE,                 /* pc_relative */
1452          0,                     /* bitpos */
1453          complain_overflow_dont, /* complain_on_overflow */
1454          ppc64_elf_unhandled_reloc, /* special_function */
1455          "R_PPC64_DTPREL16_HIGHEST", /* name */
1456          FALSE,                 /* partial_inplace */
1457          0,                     /* src_mask */
1458          0xffff,                /* dst_mask */
1459          FALSE),                /* pcrel_offset */
1460
1461   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1462   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1463          48,                    /* rightshift */
1464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          16,                    /* bitsize */
1466          FALSE,                 /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_dont, /* complain_on_overflow */
1469          ppc64_elf_unhandled_reloc, /* special_function */
1470          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1471          FALSE,                 /* partial_inplace */
1472          0,                     /* src_mask */
1473          0xffff,                /* dst_mask */
1474          FALSE),                /* pcrel_offset */
1475
1476   /* Like DTPREL16, but for insns with a DS field.  */
1477   HOWTO (R_PPC64_DTPREL16_DS,
1478          0,                     /* rightshift */
1479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1480          16,                    /* bitsize */
1481          FALSE,                 /* pc_relative */
1482          0,                     /* bitpos */
1483          complain_overflow_signed, /* complain_on_overflow */
1484          ppc64_elf_unhandled_reloc, /* special_function */
1485          "R_PPC64_DTPREL16_DS", /* name */
1486          FALSE,                 /* partial_inplace */
1487          0,                     /* src_mask */
1488          0xfffc,                /* dst_mask */
1489          FALSE),                /* pcrel_offset */
1490
1491   /* Like DTPREL16_DS, but no overflow.  */
1492   HOWTO (R_PPC64_DTPREL16_LO_DS,
1493          0,                     /* rightshift */
1494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          16,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          ppc64_elf_unhandled_reloc, /* special_function */
1500          "R_PPC64_DTPREL16_LO_DS", /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          0xfffc,                /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* Computes a tp-relative displacement, the difference between the value of
1507      sym+add and the value of the thread pointer (r13).  */
1508   HOWTO (R_PPC64_TPREL64,
1509          0,                     /* rightshift */
1510          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1511          64,                    /* bitsize */
1512          FALSE,                 /* pc_relative */
1513          0,                     /* bitpos */
1514          complain_overflow_dont, /* complain_on_overflow */
1515          ppc64_elf_unhandled_reloc, /* special_function */
1516          "R_PPC64_TPREL64",     /* name */
1517          FALSE,                 /* partial_inplace */
1518          0,                     /* src_mask */
1519          ONES (64),             /* dst_mask */
1520          FALSE),                /* pcrel_offset */
1521
1522   /* A 16 bit tprel reloc.  */
1523   HOWTO (R_PPC64_TPREL16,
1524          0,                     /* rightshift */
1525          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1526          16,                    /* bitsize */
1527          FALSE,                 /* pc_relative */
1528          0,                     /* bitpos */
1529          complain_overflow_signed, /* complain_on_overflow */
1530          ppc64_elf_unhandled_reloc, /* special_function */
1531          "R_PPC64_TPREL16",     /* name */
1532          FALSE,                 /* partial_inplace */
1533          0,                     /* src_mask */
1534          0xffff,                /* dst_mask */
1535          FALSE),                /* pcrel_offset */
1536
1537   /* Like TPREL16, but no overflow.  */
1538   HOWTO (R_PPC64_TPREL16_LO,
1539          0,                     /* rightshift */
1540          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1541          16,                    /* bitsize */
1542          FALSE,                 /* pc_relative */
1543          0,                     /* bitpos */
1544          complain_overflow_dont, /* complain_on_overflow */
1545          ppc64_elf_unhandled_reloc, /* special_function */
1546          "R_PPC64_TPREL16_LO",  /* name */
1547          FALSE,                 /* partial_inplace */
1548          0,                     /* src_mask */
1549          0xffff,                /* dst_mask */
1550          FALSE),                /* pcrel_offset */
1551
1552   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1553   HOWTO (R_PPC64_TPREL16_HI,
1554          16,                    /* rightshift */
1555          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1556          16,                    /* bitsize */
1557          FALSE,                 /* pc_relative */
1558          0,                     /* bitpos */
1559          complain_overflow_signed, /* complain_on_overflow */
1560          ppc64_elf_unhandled_reloc, /* special_function */
1561          "R_PPC64_TPREL16_HI",  /* name */
1562          FALSE,                 /* partial_inplace */
1563          0,                     /* src_mask */
1564          0xffff,                /* dst_mask */
1565          FALSE),                /* pcrel_offset */
1566
1567   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1568   HOWTO (R_PPC64_TPREL16_HA,
1569          16,                    /* rightshift */
1570          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1571          16,                    /* bitsize */
1572          FALSE,                 /* pc_relative */
1573          0,                     /* bitpos */
1574          complain_overflow_signed, /* complain_on_overflow */
1575          ppc64_elf_unhandled_reloc, /* special_function */
1576          "R_PPC64_TPREL16_HA",  /* name */
1577          FALSE,                 /* partial_inplace */
1578          0,                     /* src_mask */
1579          0xffff,                /* dst_mask */
1580          FALSE),                /* pcrel_offset */
1581
1582   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1583   HOWTO (R_PPC64_TPREL16_HIGHER,
1584          32,                    /* rightshift */
1585          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1586          16,                    /* bitsize */
1587          FALSE,                 /* pc_relative */
1588          0,                     /* bitpos */
1589          complain_overflow_dont, /* complain_on_overflow */
1590          ppc64_elf_unhandled_reloc, /* special_function */
1591          "R_PPC64_TPREL16_HIGHER",      /* name */
1592          FALSE,                 /* partial_inplace */
1593          0,                     /* src_mask */
1594          0xffff,                /* dst_mask */
1595          FALSE),                /* pcrel_offset */
1596
1597   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1598   HOWTO (R_PPC64_TPREL16_HIGHERA,
1599          32,                    /* rightshift */
1600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1601          16,                    /* bitsize */
1602          FALSE,                 /* pc_relative */
1603          0,                     /* bitpos */
1604          complain_overflow_dont, /* complain_on_overflow */
1605          ppc64_elf_unhandled_reloc, /* special_function */
1606          "R_PPC64_TPREL16_HIGHERA", /* name */
1607          FALSE,                 /* partial_inplace */
1608          0,                     /* src_mask */
1609          0xffff,                /* dst_mask */
1610          FALSE),                /* pcrel_offset */
1611
1612   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1613   HOWTO (R_PPC64_TPREL16_HIGHEST,
1614          48,                    /* rightshift */
1615          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1616          16,                    /* bitsize */
1617          FALSE,                 /* pc_relative */
1618          0,                     /* bitpos */
1619          complain_overflow_dont, /* complain_on_overflow */
1620          ppc64_elf_unhandled_reloc, /* special_function */
1621          "R_PPC64_TPREL16_HIGHEST", /* name */
1622          FALSE,                 /* partial_inplace */
1623          0,                     /* src_mask */
1624          0xffff,                /* dst_mask */
1625          FALSE),                /* pcrel_offset */
1626
1627   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1628   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1629          48,                    /* rightshift */
1630          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1631          16,                    /* bitsize */
1632          FALSE,                 /* pc_relative */
1633          0,                     /* bitpos */
1634          complain_overflow_dont, /* complain_on_overflow */
1635          ppc64_elf_unhandled_reloc, /* special_function */
1636          "R_PPC64_TPREL16_HIGHESTA", /* name */
1637          FALSE,                 /* partial_inplace */
1638          0,                     /* src_mask */
1639          0xffff,                /* dst_mask */
1640          FALSE),                /* pcrel_offset */
1641
1642   /* Like TPREL16, but for insns with a DS field.  */
1643   HOWTO (R_PPC64_TPREL16_DS,
1644          0,                     /* rightshift */
1645          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1646          16,                    /* bitsize */
1647          FALSE,                 /* pc_relative */
1648          0,                     /* bitpos */
1649          complain_overflow_signed, /* complain_on_overflow */
1650          ppc64_elf_unhandled_reloc, /* special_function */
1651          "R_PPC64_TPREL16_DS",  /* name */
1652          FALSE,                 /* partial_inplace */
1653          0,                     /* src_mask */
1654          0xfffc,                /* dst_mask */
1655          FALSE),                /* pcrel_offset */
1656
1657   /* Like TPREL16_DS, but no overflow.  */
1658   HOWTO (R_PPC64_TPREL16_LO_DS,
1659          0,                     /* rightshift */
1660          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1661          16,                    /* bitsize */
1662          FALSE,                 /* pc_relative */
1663          0,                     /* bitpos */
1664          complain_overflow_dont, /* complain_on_overflow */
1665          ppc64_elf_unhandled_reloc, /* special_function */
1666          "R_PPC64_TPREL16_LO_DS", /* name */
1667          FALSE,                 /* partial_inplace */
1668          0,                     /* src_mask */
1669          0xfffc,                /* dst_mask */
1670          FALSE),                /* pcrel_offset */
1671
1672   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1673      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1674      to the first entry relative to the TOC base (r2).  */
1675   HOWTO (R_PPC64_GOT_TLSGD16,
1676          0,                     /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          16,                    /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_signed, /* complain_on_overflow */
1682          ppc64_elf_unhandled_reloc, /* special_function */
1683          "R_PPC64_GOT_TLSGD16", /* name */
1684          FALSE,                 /* partial_inplace */
1685          0,                     /* src_mask */
1686          0xffff,                /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688
1689   /* Like GOT_TLSGD16, but no overflow.  */
1690   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1691          0,                     /* rightshift */
1692          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1693          16,                    /* bitsize */
1694          FALSE,                 /* pc_relative */
1695          0,                     /* bitpos */
1696          complain_overflow_dont, /* complain_on_overflow */
1697          ppc64_elf_unhandled_reloc, /* special_function */
1698          "R_PPC64_GOT_TLSGD16_LO", /* name */
1699          FALSE,                 /* partial_inplace */
1700          0,                     /* src_mask */
1701          0xffff,                /* dst_mask */
1702          FALSE),                /* pcrel_offset */
1703
1704   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1705   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1706          16,                    /* rightshift */
1707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1708          16,                    /* bitsize */
1709          FALSE,                 /* pc_relative */
1710          0,                     /* bitpos */
1711          complain_overflow_signed, /* complain_on_overflow */
1712          ppc64_elf_unhandled_reloc, /* special_function */
1713          "R_PPC64_GOT_TLSGD16_HI", /* name */
1714          FALSE,                 /* partial_inplace */
1715          0,                     /* src_mask */
1716          0xffff,                /* dst_mask */
1717          FALSE),                /* pcrel_offset */
1718
1719   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1720   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1721          16,                    /* rightshift */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1723          16,                    /* bitsize */
1724          FALSE,                 /* pc_relative */
1725          0,                     /* bitpos */
1726          complain_overflow_signed, /* complain_on_overflow */
1727          ppc64_elf_unhandled_reloc, /* special_function */
1728          "R_PPC64_GOT_TLSGD16_HA", /* name */
1729          FALSE,                 /* partial_inplace */
1730          0,                     /* src_mask */
1731          0xffff,                /* dst_mask */
1732          FALSE),                /* pcrel_offset */
1733
1734   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735      with values (sym+add)@dtpmod and zero, and computes the offset to the
1736      first entry relative to the TOC base (r2).  */
1737   HOWTO (R_PPC64_GOT_TLSLD16,
1738          0,                     /* rightshift */
1739          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1740          16,                    /* bitsize */
1741          FALSE,                 /* pc_relative */
1742          0,                     /* bitpos */
1743          complain_overflow_signed, /* complain_on_overflow */
1744          ppc64_elf_unhandled_reloc, /* special_function */
1745          "R_PPC64_GOT_TLSLD16", /* name */
1746          FALSE,                 /* partial_inplace */
1747          0,                     /* src_mask */
1748          0xffff,                /* dst_mask */
1749          FALSE),                /* pcrel_offset */
1750
1751   /* Like GOT_TLSLD16, but no overflow.  */
1752   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1753          0,                     /* rightshift */
1754          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1755          16,                    /* bitsize */
1756          FALSE,                 /* pc_relative */
1757          0,                     /* bitpos */
1758          complain_overflow_dont, /* complain_on_overflow */
1759          ppc64_elf_unhandled_reloc, /* special_function */
1760          "R_PPC64_GOT_TLSLD16_LO", /* name */
1761          FALSE,                 /* partial_inplace */
1762          0,                     /* src_mask */
1763          0xffff,                /* dst_mask */
1764          FALSE),                /* pcrel_offset */
1765
1766   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1767   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1768          16,                    /* rightshift */
1769          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1770          16,                    /* bitsize */
1771          FALSE,                 /* pc_relative */
1772          0,                     /* bitpos */
1773          complain_overflow_signed, /* complain_on_overflow */
1774          ppc64_elf_unhandled_reloc, /* special_function */
1775          "R_PPC64_GOT_TLSLD16_HI", /* name */
1776          FALSE,                 /* partial_inplace */
1777          0,                     /* src_mask */
1778          0xffff,                /* dst_mask */
1779          FALSE),                /* pcrel_offset */
1780
1781   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1782   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1783          16,                    /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_TLSLD16_HA", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xffff,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1797      the offset to the entry relative to the TOC base (r2).  */
1798   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1799          0,                     /* rightshift */
1800          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1801          16,                    /* bitsize */
1802          FALSE,                 /* pc_relative */
1803          0,                     /* bitpos */
1804          complain_overflow_signed, /* complain_on_overflow */
1805          ppc64_elf_unhandled_reloc, /* special_function */
1806          "R_PPC64_GOT_DTPREL16_DS", /* name */
1807          FALSE,                 /* partial_inplace */
1808          0,                     /* src_mask */
1809          0xfffc,                /* dst_mask */
1810          FALSE),                /* pcrel_offset */
1811
1812   /* Like GOT_DTPREL16_DS, but no overflow.  */
1813   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1814          0,                     /* rightshift */
1815          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1816          16,                    /* bitsize */
1817          FALSE,                 /* pc_relative */
1818          0,                     /* bitpos */
1819          complain_overflow_dont, /* complain_on_overflow */
1820          ppc64_elf_unhandled_reloc, /* special_function */
1821          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1822          FALSE,                 /* partial_inplace */
1823          0,                     /* src_mask */
1824          0xfffc,                /* dst_mask */
1825          FALSE),                /* pcrel_offset */
1826
1827   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1828   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1829          16,                    /* rightshift */
1830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1831          16,                    /* bitsize */
1832          FALSE,                 /* pc_relative */
1833          0,                     /* bitpos */
1834          complain_overflow_signed, /* complain_on_overflow */
1835          ppc64_elf_unhandled_reloc, /* special_function */
1836          "R_PPC64_GOT_DTPREL16_HI", /* name */
1837          FALSE,                 /* partial_inplace */
1838          0,                     /* src_mask */
1839          0xffff,                /* dst_mask */
1840          FALSE),                /* pcrel_offset */
1841
1842   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1843   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1844          16,                    /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_DTPREL16_HA", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xffff,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1858      offset to the entry relative to the TOC base (r2).  */
1859   HOWTO (R_PPC64_GOT_TPREL16_DS,
1860          0,                     /* rightshift */
1861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1862          16,                    /* bitsize */
1863          FALSE,                 /* pc_relative */
1864          0,                     /* bitpos */
1865          complain_overflow_signed, /* complain_on_overflow */
1866          ppc64_elf_unhandled_reloc, /* special_function */
1867          "R_PPC64_GOT_TPREL16_DS", /* name */
1868          FALSE,                 /* partial_inplace */
1869          0,                     /* src_mask */
1870          0xfffc,                /* dst_mask */
1871          FALSE),                /* pcrel_offset */
1872
1873   /* Like GOT_TPREL16_DS, but no overflow.  */
1874   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1875          0,                     /* rightshift */
1876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1877          16,                    /* bitsize */
1878          FALSE,                 /* pc_relative */
1879          0,                     /* bitpos */
1880          complain_overflow_dont, /* complain_on_overflow */
1881          ppc64_elf_unhandled_reloc, /* special_function */
1882          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1883          FALSE,                 /* partial_inplace */
1884          0,                     /* src_mask */
1885          0xfffc,                /* dst_mask */
1886          FALSE),                /* pcrel_offset */
1887
1888   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1889   HOWTO (R_PPC64_GOT_TPREL16_HI,
1890          16,                    /* rightshift */
1891          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1892          16,                    /* bitsize */
1893          FALSE,                 /* pc_relative */
1894          0,                     /* bitpos */
1895          complain_overflow_signed, /* complain_on_overflow */
1896          ppc64_elf_unhandled_reloc, /* special_function */
1897          "R_PPC64_GOT_TPREL16_HI", /* name */
1898          FALSE,                 /* partial_inplace */
1899          0,                     /* src_mask */
1900          0xffff,                /* dst_mask */
1901          FALSE),                /* pcrel_offset */
1902
1903   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1904   HOWTO (R_PPC64_GOT_TPREL16_HA,
1905          16,                    /* rightshift */
1906          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1907          16,                    /* bitsize */
1908          FALSE,                 /* pc_relative */
1909          0,                     /* bitpos */
1910          complain_overflow_signed, /* complain_on_overflow */
1911          ppc64_elf_unhandled_reloc, /* special_function */
1912          "R_PPC64_GOT_TPREL16_HA", /* name */
1913          FALSE,                 /* partial_inplace */
1914          0,                     /* src_mask */
1915          0xffff,                /* dst_mask */
1916          FALSE),                /* pcrel_offset */
1917
1918   HOWTO (R_PPC64_JMP_IREL,      /* type */
1919          0,                     /* rightshift */
1920          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1921          0,                     /* bitsize */
1922          FALSE,                 /* pc_relative */
1923          0,                     /* bitpos */
1924          complain_overflow_dont, /* complain_on_overflow */
1925          ppc64_elf_unhandled_reloc, /* special_function */
1926          "R_PPC64_JMP_IREL",    /* name */
1927          FALSE,                 /* partial_inplace */
1928          0,                     /* src_mask */
1929          0,                     /* dst_mask */
1930          FALSE),                /* pcrel_offset */
1931
1932   HOWTO (R_PPC64_IRELATIVE,     /* type */
1933          0,                     /* rightshift */
1934          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935          64,                    /* bitsize */
1936          FALSE,                 /* pc_relative */
1937          0,                     /* bitpos */
1938          complain_overflow_dont, /* complain_on_overflow */
1939          bfd_elf_generic_reloc, /* special_function */
1940          "R_PPC64_IRELATIVE",   /* name */
1941          FALSE,                 /* partial_inplace */
1942          0,                     /* src_mask */
1943          ONES (64),             /* dst_mask */
1944          FALSE),                /* pcrel_offset */
1945
1946   /* A 16 bit relative relocation.  */
1947   HOWTO (R_PPC64_REL16,         /* type */
1948          0,                     /* rightshift */
1949          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1950          16,                    /* bitsize */
1951          TRUE,                  /* pc_relative */
1952          0,                     /* bitpos */
1953          complain_overflow_bitfield, /* complain_on_overflow */
1954          bfd_elf_generic_reloc, /* special_function */
1955          "R_PPC64_REL16",       /* name */
1956          FALSE,                 /* partial_inplace */
1957          0,                     /* src_mask */
1958          0xffff,                /* dst_mask */
1959          TRUE),                 /* pcrel_offset */
1960
1961   /* A 16 bit relative relocation without overflow.  */
1962   HOWTO (R_PPC64_REL16_LO,      /* type */
1963          0,                     /* rightshift */
1964          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1965          16,                    /* bitsize */
1966          TRUE,                  /* pc_relative */
1967          0,                     /* bitpos */
1968          complain_overflow_dont,/* complain_on_overflow */
1969          bfd_elf_generic_reloc, /* special_function */
1970          "R_PPC64_REL16_LO",    /* name */
1971          FALSE,                 /* partial_inplace */
1972          0,                     /* src_mask */
1973          0xffff,                /* dst_mask */
1974          TRUE),                 /* pcrel_offset */
1975
1976   /* The high order 16 bits of a relative address.  */
1977   HOWTO (R_PPC64_REL16_HI,      /* type */
1978          16,                    /* rightshift */
1979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1980          16,                    /* bitsize */
1981          TRUE,                  /* pc_relative */
1982          0,                     /* bitpos */
1983          complain_overflow_signed, /* complain_on_overflow */
1984          bfd_elf_generic_reloc, /* special_function */
1985          "R_PPC64_REL16_HI",    /* name */
1986          FALSE,                 /* partial_inplace */
1987          0,                     /* src_mask */
1988          0xffff,                /* dst_mask */
1989          TRUE),                 /* pcrel_offset */
1990
1991   /* The high order 16 bits of a relative address, plus 1 if the contents of
1992      the low 16 bits, treated as a signed number, is negative.  */
1993   HOWTO (R_PPC64_REL16_HA,      /* type */
1994          16,                    /* rightshift */
1995          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1996          16,                    /* bitsize */
1997          TRUE,                  /* pc_relative */
1998          0,                     /* bitpos */
1999          complain_overflow_signed, /* complain_on_overflow */
2000          ppc64_elf_ha_reloc,    /* special_function */
2001          "R_PPC64_REL16_HA",    /* name */
2002          FALSE,                 /* partial_inplace */
2003          0,                     /* src_mask */
2004          0xffff,                /* dst_mask */
2005          TRUE),                 /* pcrel_offset */
2006
2007   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2008   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2009          16,                    /* rightshift */
2010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2011          16,                    /* bitsize */
2012          FALSE,                 /* pc_relative */
2013          0,                     /* bitpos */
2014          complain_overflow_dont, /* complain_on_overflow */
2015          bfd_elf_generic_reloc, /* special_function */
2016          "R_PPC64_ADDR16_HIGH", /* name */
2017          FALSE,                 /* partial_inplace */
2018          0,                     /* src_mask */
2019          0xffff,                /* dst_mask */
2020          FALSE),                /* pcrel_offset */
2021
2022   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2023   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2024          16,                    /* rightshift */
2025          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2026          16,                    /* bitsize */
2027          FALSE,                 /* pc_relative */
2028          0,                     /* bitpos */
2029          complain_overflow_dont, /* complain_on_overflow */
2030          ppc64_elf_ha_reloc,    /* special_function */
2031          "R_PPC64_ADDR16_HIGHA",        /* name */
2032          FALSE,                 /* partial_inplace */
2033          0,                     /* src_mask */
2034          0xffff,                /* dst_mask */
2035          FALSE),                /* pcrel_offset */
2036
2037   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2038   HOWTO (R_PPC64_DTPREL16_HIGH,
2039          16,                    /* rightshift */
2040          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2041          16,                    /* bitsize */
2042          FALSE,                 /* pc_relative */
2043          0,                     /* bitpos */
2044          complain_overflow_dont, /* complain_on_overflow */
2045          ppc64_elf_unhandled_reloc, /* special_function */
2046          "R_PPC64_DTPREL16_HIGH", /* name */
2047          FALSE,                 /* partial_inplace */
2048          0,                     /* src_mask */
2049          0xffff,                /* dst_mask */
2050          FALSE),                /* pcrel_offset */
2051
2052   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2053   HOWTO (R_PPC64_DTPREL16_HIGHA,
2054          16,                    /* rightshift */
2055          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2056          16,                    /* bitsize */
2057          FALSE,                 /* pc_relative */
2058          0,                     /* bitpos */
2059          complain_overflow_dont, /* complain_on_overflow */
2060          ppc64_elf_unhandled_reloc, /* special_function */
2061          "R_PPC64_DTPREL16_HIGHA", /* name */
2062          FALSE,                 /* partial_inplace */
2063          0,                     /* src_mask */
2064          0xffff,                /* dst_mask */
2065          FALSE),                /* pcrel_offset */
2066
2067   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2068   HOWTO (R_PPC64_TPREL16_HIGH,
2069          16,                    /* rightshift */
2070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2071          16,                    /* bitsize */
2072          FALSE,                 /* pc_relative */
2073          0,                     /* bitpos */
2074          complain_overflow_dont, /* complain_on_overflow */
2075          ppc64_elf_unhandled_reloc, /* special_function */
2076          "R_PPC64_TPREL16_HIGH",        /* name */
2077          FALSE,                 /* partial_inplace */
2078          0,                     /* src_mask */
2079          0xffff,                /* dst_mask */
2080          FALSE),                /* pcrel_offset */
2081
2082   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2083   HOWTO (R_PPC64_TPREL16_HIGHA,
2084          16,                    /* rightshift */
2085          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2086          16,                    /* bitsize */
2087          FALSE,                 /* pc_relative */
2088          0,                     /* bitpos */
2089          complain_overflow_dont, /* complain_on_overflow */
2090          ppc64_elf_unhandled_reloc, /* special_function */
2091          "R_PPC64_TPREL16_HIGHA",       /* name */
2092          FALSE,                 /* partial_inplace */
2093          0,                     /* src_mask */
2094          0xffff,                /* dst_mask */
2095          FALSE),                /* pcrel_offset */
2096
2097   /* Like ADDR64, but use local entry point of function.  */
2098   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2099          0,                     /* rightshift */
2100          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2101          64,                    /* bitsize */
2102          FALSE,                 /* pc_relative */
2103          0,                     /* bitpos */
2104          complain_overflow_dont, /* complain_on_overflow */
2105          bfd_elf_generic_reloc, /* special_function */
2106          "R_PPC64_ADDR64_LOCAL", /* name */
2107          FALSE,                 /* partial_inplace */
2108          0,                     /* src_mask */
2109          ONES (64),             /* dst_mask */
2110          FALSE),                /* pcrel_offset */
2111
2112   /* GNU extension to record C++ vtable hierarchy.  */
2113   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2114          0,                     /* rightshift */
2115          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2116          0,                     /* bitsize */
2117          FALSE,                 /* pc_relative */
2118          0,                     /* bitpos */
2119          complain_overflow_dont, /* complain_on_overflow */
2120          NULL,                  /* special_function */
2121          "R_PPC64_GNU_VTINHERIT", /* name */
2122          FALSE,                 /* partial_inplace */
2123          0,                     /* src_mask */
2124          0,                     /* dst_mask */
2125          FALSE),                /* pcrel_offset */
2126
2127   /* GNU extension to record C++ vtable member usage.  */
2128   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2129          0,                     /* rightshift */
2130          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2131          0,                     /* bitsize */
2132          FALSE,                 /* pc_relative */
2133          0,                     /* bitpos */
2134          complain_overflow_dont, /* complain_on_overflow */
2135          NULL,                  /* special_function */
2136          "R_PPC64_GNU_VTENTRY", /* name */
2137          FALSE,                 /* partial_inplace */
2138          0,                     /* src_mask */
2139          0,                     /* dst_mask */
2140          FALSE),                /* pcrel_offset */
2141 };
2142
2143 \f
2144 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2145    be done.  */
2146
2147 static void
2148 ppc_howto_init (void)
2149 {
2150   unsigned int i, type;
2151
2152   for (i = 0;
2153        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2154        i++)
2155     {
2156       type = ppc64_elf_howto_raw[i].type;
2157       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2158                           / sizeof (ppc64_elf_howto_table[0])));
2159       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2160     }
2161 }
2162
2163 static reloc_howto_type *
2164 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2165                              bfd_reloc_code_real_type code)
2166 {
2167   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2168
2169   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2170     /* Initialize howto table if needed.  */
2171     ppc_howto_init ();
2172
2173   switch (code)
2174     {
2175     default:
2176       return NULL;
2177
2178     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2179       break;
2180     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2181       break;
2182     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2183       break;
2184     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2185       break;
2186     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2187       break;
2188     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2189       break;
2190     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2191       break;
2192     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2193       break;
2194     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2195       break;
2196     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2197       break;
2198     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2199       break;
2200     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2201       break;
2202     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2203       break;
2204     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2205       break;
2206     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2207       break;
2208     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2209       break;
2210     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2211       break;
2212     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2213       break;
2214     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2215       break;
2216     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2217       break;
2218     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2219       break;
2220     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2221       break;
2222     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2223       break;
2224     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2225       break;
2226     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2227       break;
2228     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2229       break;
2230     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2231       break;
2232     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2233       break;
2234     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2235       break;
2236     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2237       break;
2238     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2241       break;
2242     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2243       break;
2244     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2245       break;
2246     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2247       break;
2248     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2249       break;
2250     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2251       break;
2252     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2253       break;
2254     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2255       break;
2256     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2257       break;
2258     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2259       break;
2260     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2261       break;
2262     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2263       break;
2264     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2265       break;
2266     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2267       break;
2268     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2269       break;
2270     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2271       break;
2272     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2273       break;
2274     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2275       break;
2276     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2277       break;
2278     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2287       break;
2288     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2289       break;
2290     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2291       break;
2292     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2293       break;
2294     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2295       break;
2296     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2297       break;
2298     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2301       break;
2302     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2303       break;
2304     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2305       break;
2306     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2307       break;
2308     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2309       break;
2310     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2321       break;
2322     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2323       break;
2324     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2325       break;
2326     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2327       break;
2328     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2329       break;
2330     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2331       break;
2332     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2333       break;
2334     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2345       break;
2346     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2347       break;
2348     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2359       break;
2360     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2361       break;
2362     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2363       break;
2364     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2365       break;
2366     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2367       break;
2368     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2369       break;
2370     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2371       break;
2372     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2373       break;
2374     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2375       break;
2376     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2377       break;
2378     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2379       break;
2380     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2381       break;
2382     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2383       break;
2384     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2385       break;
2386     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2387       break;
2388     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2389       break;
2390     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2391       break;
2392     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2393       break;
2394     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2395       break;
2396     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2397       break;
2398     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2399       break;
2400     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2401       break;
2402     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2403       break;
2404     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2405       break;
2406     }
2407
2408   return ppc64_elf_howto_table[r];
2409 };
2410
2411 static reloc_howto_type *
2412 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2413                              const char *r_name)
2414 {
2415   unsigned int i;
2416
2417   for (i = 0;
2418        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2419        i++)
2420     if (ppc64_elf_howto_raw[i].name != NULL
2421         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2422       return &ppc64_elf_howto_raw[i];
2423
2424   return NULL;
2425 }
2426
2427 /* Set the howto pointer for a PowerPC ELF reloc.  */
2428
2429 static void
2430 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2431                          Elf_Internal_Rela *dst)
2432 {
2433   unsigned int type;
2434
2435   /* Initialize howto table if needed.  */
2436   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2437     ppc_howto_init ();
2438
2439   type = ELF64_R_TYPE (dst->r_info);
2440   if (type >= (sizeof (ppc64_elf_howto_table)
2441                / sizeof (ppc64_elf_howto_table[0])))
2442     {
2443       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2444                              abfd, (int) type);
2445       type = R_PPC64_NONE;
2446     }
2447   cache_ptr->howto = ppc64_elf_howto_table[type];
2448 }
2449
2450 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2451
2452 static bfd_reloc_status_type
2453 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2454                     void *data, asection *input_section,
2455                     bfd *output_bfd, char **error_message)
2456 {
2457   /* If this is a relocatable link (output_bfd test tells us), just
2458      call the generic function.  Any adjustment will be done at final
2459      link time.  */
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462                                   input_section, output_bfd, error_message);
2463
2464   /* Adjust the addend for sign extension of the low 16 bits.
2465      We won't actually be using the low 16 bits, so trashing them
2466      doesn't matter.  */
2467   reloc_entry->addend += 0x8000;
2468   return bfd_reloc_continue;
2469 }
2470
2471 static bfd_reloc_status_type
2472 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2473                         void *data, asection *input_section,
2474                         bfd *output_bfd, char **error_message)
2475 {
2476   if (output_bfd != NULL)
2477     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478                                   input_section, output_bfd, error_message);
2479
2480   if (strcmp (symbol->section->name, ".opd") == 0
2481       && (symbol->section->owner->flags & DYNAMIC) == 0)
2482     {
2483       bfd_vma dest = opd_entry_value (symbol->section,
2484                                       symbol->value + reloc_entry->addend,
2485                                       NULL, NULL, FALSE);
2486       if (dest != (bfd_vma) -1)
2487         reloc_entry->addend = dest - (symbol->value
2488                                       + symbol->section->output_section->vma
2489                                       + symbol->section->output_offset);
2490     }
2491   return bfd_reloc_continue;
2492 }
2493
2494 static bfd_reloc_status_type
2495 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2496                          void *data, asection *input_section,
2497                          bfd *output_bfd, char **error_message)
2498 {
2499   long insn;
2500   enum elf_ppc64_reloc_type r_type;
2501   bfd_size_type octets;
2502   /* Assume 'at' branch hints.  */
2503   bfd_boolean is_isa_v2 = TRUE;
2504
2505   /* If this is a relocatable link (output_bfd test tells us), just
2506      call the generic function.  Any adjustment will be done at final
2507      link time.  */
2508   if (output_bfd != NULL)
2509     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2510                                   input_section, output_bfd, error_message);
2511
2512   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2513   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2514   insn &= ~(0x01 << 21);
2515   r_type = reloc_entry->howto->type;
2516   if (r_type == R_PPC64_ADDR14_BRTAKEN
2517       || r_type == R_PPC64_REL14_BRTAKEN)
2518     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2519
2520   if (is_isa_v2)
2521     {
2522       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2523          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2524          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2525       if ((insn & (0x14 << 21)) == (0x04 << 21))
2526         insn |= 0x02 << 21;
2527       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2528         insn |= 0x08 << 21;
2529       else
2530         goto out;
2531     }
2532   else
2533     {
2534       bfd_vma target = 0;
2535       bfd_vma from;
2536
2537       if (!bfd_is_com_section (symbol->section))
2538         target = symbol->value;
2539       target += symbol->section->output_section->vma;
2540       target += symbol->section->output_offset;
2541       target += reloc_entry->addend;
2542
2543       from = (reloc_entry->address
2544               + input_section->output_offset
2545               + input_section->output_section->vma);
2546
2547       /* Invert 'y' bit if not the default.  */
2548       if ((bfd_signed_vma) (target - from) < 0)
2549         insn ^= 0x01 << 21;
2550     }
2551   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2552  out:
2553   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2554                                  input_section, output_bfd, error_message);
2555 }
2556
2557 static bfd_reloc_status_type
2558 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2559                          void *data, asection *input_section,
2560                          bfd *output_bfd, char **error_message)
2561 {
2562   /* If this is a relocatable link (output_bfd test tells us), just
2563      call the generic function.  Any adjustment will be done at final
2564      link time.  */
2565   if (output_bfd != NULL)
2566     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2567                                   input_section, output_bfd, error_message);
2568
2569   /* Subtract the symbol section base address.  */
2570   reloc_entry->addend -= symbol->section->output_section->vma;
2571   return bfd_reloc_continue;
2572 }
2573
2574 static bfd_reloc_status_type
2575 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2576                             void *data, asection *input_section,
2577                             bfd *output_bfd, char **error_message)
2578 {
2579   /* If this is a relocatable link (output_bfd test tells us), just
2580      call the generic function.  Any adjustment will be done at final
2581      link time.  */
2582   if (output_bfd != NULL)
2583     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2584                                   input_section, output_bfd, error_message);
2585
2586   /* Subtract the symbol section base address.  */
2587   reloc_entry->addend -= symbol->section->output_section->vma;
2588
2589   /* Adjust the addend for sign extension of the low 16 bits.  */
2590   reloc_entry->addend += 0x8000;
2591   return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596                      void *data, asection *input_section,
2597                      bfd *output_bfd, char **error_message)
2598 {
2599   bfd_vma TOCstart;
2600
2601   /* If this is a relocatable link (output_bfd test tells us), just
2602      call the generic function.  Any adjustment will be done at final
2603      link time.  */
2604   if (output_bfd != NULL)
2605     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2606                                   input_section, output_bfd, error_message);
2607
2608   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2609   if (TOCstart == 0)
2610     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2611
2612   /* Subtract the TOC base address.  */
2613   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2614   return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619                         void *data, asection *input_section,
2620                         bfd *output_bfd, char **error_message)
2621 {
2622   bfd_vma TOCstart;
2623
2624   /* If this is a relocatable link (output_bfd test tells us), just
2625      call the generic function.  Any adjustment will be done at final
2626      link time.  */
2627   if (output_bfd != NULL)
2628     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2629                                   input_section, output_bfd, error_message);
2630
2631   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2632   if (TOCstart == 0)
2633     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2634
2635   /* Subtract the TOC base address.  */
2636   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2637
2638   /* Adjust the addend for sign extension of the low 16 bits.  */
2639   reloc_entry->addend += 0x8000;
2640   return bfd_reloc_continue;
2641 }
2642
2643 static bfd_reloc_status_type
2644 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2645                        void *data, asection *input_section,
2646                        bfd *output_bfd, char **error_message)
2647 {
2648   bfd_vma TOCstart;
2649   bfd_size_type octets;
2650
2651   /* If this is a relocatable link (output_bfd test tells us), just
2652      call the generic function.  Any adjustment will be done at final
2653      link time.  */
2654   if (output_bfd != NULL)
2655     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2656                                   input_section, output_bfd, error_message);
2657
2658   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2659   if (TOCstart == 0)
2660     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2661
2662   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2663   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2664   return bfd_reloc_ok;
2665 }
2666
2667 static bfd_reloc_status_type
2668 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2669                            void *data, asection *input_section,
2670                            bfd *output_bfd, char **error_message)
2671 {
2672   /* If this is a relocatable link (output_bfd test tells us), just
2673      call the generic function.  Any adjustment will be done at final
2674      link time.  */
2675   if (output_bfd != NULL)
2676     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2677                                   input_section, output_bfd, error_message);
2678
2679   if (error_message != NULL)
2680     {
2681       static char buf[60];
2682       sprintf (buf, "generic linker can't handle %s",
2683                reloc_entry->howto->name);
2684       *error_message = buf;
2685     }
2686   return bfd_reloc_dangerous;
2687 }
2688
2689 /* Track GOT entries needed for a given symbol.  We might need more
2690    than one got entry per symbol.  */
2691 struct got_entry
2692 {
2693   struct got_entry *next;
2694
2695   /* The symbol addend that we'll be placing in the GOT.  */
2696   bfd_vma addend;
2697
2698   /* Unlike other ELF targets, we use separate GOT entries for the same
2699      symbol referenced from different input files.  This is to support
2700      automatic multiple TOC/GOT sections, where the TOC base can vary
2701      from one input file to another.  After partitioning into TOC groups
2702      we merge entries within the group.
2703
2704      Point to the BFD owning this GOT entry.  */
2705   bfd *owner;
2706
2707   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2708      TLS_TPREL or TLS_DTPREL for tls entries.  */
2709   unsigned char tls_type;
2710
2711   /* Non-zero if got.ent points to real entry.  */
2712   unsigned char is_indirect;
2713
2714   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2715   union
2716     {
2717       bfd_signed_vma refcount;
2718       bfd_vma offset;
2719       struct got_entry *ent;
2720     } got;
2721 };
2722
2723 /* The same for PLT.  */
2724 struct plt_entry
2725 {
2726   struct plt_entry *next;
2727
2728   bfd_vma addend;
2729
2730   union
2731     {
2732       bfd_signed_vma refcount;
2733       bfd_vma offset;
2734     } plt;
2735 };
2736
2737 struct ppc64_elf_obj_tdata
2738 {
2739   struct elf_obj_tdata elf;
2740
2741   /* Shortcuts to dynamic linker sections.  */
2742   asection *got;
2743   asection *relgot;
2744
2745   /* Used during garbage collection.  We attach global symbols defined
2746      on removed .opd entries to this section so that the sym is removed.  */
2747   asection *deleted_section;
2748
2749   /* TLS local dynamic got entry handling.  Support for multiple GOT
2750      sections means we potentially need one of these for each input bfd.  */
2751   struct got_entry tlsld_got;
2752
2753   union {
2754     /* A copy of relocs before they are modified for --emit-relocs.  */
2755     Elf_Internal_Rela *relocs;
2756
2757     /* Section contents.  */
2758     bfd_byte *contents;
2759   } opd;
2760
2761   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2762      the reloc to be in the range -32768 to 32767.  */
2763   unsigned int has_small_toc_reloc : 1;
2764
2765   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2766      instruction not one we handle.  */
2767   unsigned int unexpected_toc_insn : 1;
2768 };
2769
2770 #define ppc64_elf_tdata(bfd) \
2771   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2772
2773 #define ppc64_tlsld_got(bfd) \
2774   (&ppc64_elf_tdata (bfd)->tlsld_got)
2775
2776 #define is_ppc64_elf(bfd) \
2777   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2778    && elf_object_id (bfd) == PPC64_ELF_DATA)
2779
2780 /* Override the generic function because we store some extras.  */
2781
2782 static bfd_boolean
2783 ppc64_elf_mkobject (bfd *abfd)
2784 {
2785   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2786                                   PPC64_ELF_DATA);
2787 }
2788
2789 /* Fix bad default arch selected for a 64 bit input bfd when the
2790    default is 32 bit.  */
2791
2792 static bfd_boolean
2793 ppc64_elf_object_p (bfd *abfd)
2794 {
2795   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2796     {
2797       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2798
2799       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2800         {
2801           /* Relies on arch after 32 bit default being 64 bit default.  */
2802           abfd->arch_info = abfd->arch_info->next;
2803           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2804         }
2805     }
2806   return TRUE;
2807 }
2808
2809 /* Support for core dump NOTE sections.  */
2810
2811 static bfd_boolean
2812 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2813 {
2814   size_t offset, size;
2815
2816   if (note->descsz != 504)
2817     return FALSE;
2818
2819   /* pr_cursig */
2820   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2821
2822   /* pr_pid */
2823   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2824
2825   /* pr_reg */
2826   offset = 112;
2827   size = 384;
2828
2829   /* Make a ".reg/999" section.  */
2830   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2831                                           size, note->descpos + offset);
2832 }
2833
2834 static bfd_boolean
2835 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2836 {
2837   if (note->descsz != 136)
2838     return FALSE;
2839
2840   elf_tdata (abfd)->core->pid
2841     = bfd_get_32 (abfd, note->descdata + 24);
2842   elf_tdata (abfd)->core->program
2843     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2844   elf_tdata (abfd)->core->command
2845     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2846
2847   return TRUE;
2848 }
2849
2850 static char *
2851 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2852                            ...)
2853 {
2854   switch (note_type)
2855     {
2856     default:
2857       return NULL;
2858
2859     case NT_PRPSINFO:
2860       {
2861         char data[136];
2862         va_list ap;
2863
2864         va_start (ap, note_type);
2865         memset (data, 0, sizeof (data));
2866         strncpy (data + 40, va_arg (ap, const char *), 16);
2867         strncpy (data + 56, va_arg (ap, const char *), 80);
2868         va_end (ap);
2869         return elfcore_write_note (abfd, buf, bufsiz,
2870                                    "CORE", note_type, data, sizeof (data));
2871       }
2872
2873     case NT_PRSTATUS:
2874       {
2875         char data[504];
2876         va_list ap;
2877         long pid;
2878         int cursig;
2879         const void *greg;
2880
2881         va_start (ap, note_type);
2882         memset (data, 0, 112);
2883         pid = va_arg (ap, long);
2884         bfd_put_32 (abfd, pid, data + 32);
2885         cursig = va_arg (ap, int);
2886         bfd_put_16 (abfd, cursig, data + 12);
2887         greg = va_arg (ap, const void *);
2888         memcpy (data + 112, greg, 384);
2889         memset (data + 496, 0, 8);
2890         va_end (ap);
2891         return elfcore_write_note (abfd, buf, bufsiz,
2892                                    "CORE", note_type, data, sizeof (data));
2893       }
2894     }
2895 }
2896
2897 /* Add extra PPC sections.  */
2898
2899 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2900 {
2901   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2902   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2903   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2906   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2907   { NULL,                     0,  0, 0,            0 }
2908 };
2909
2910 enum _ppc64_sec_type {
2911   sec_normal = 0,
2912   sec_opd = 1,
2913   sec_toc = 2
2914 };
2915
2916 struct _ppc64_elf_section_data
2917 {
2918   struct bfd_elf_section_data elf;
2919
2920   union
2921   {
2922     /* An array with one entry for each opd function descriptor.  */
2923     struct _opd_sec_data
2924     {
2925       /* Points to the function code section for local opd entries.  */
2926       asection **func_sec;
2927
2928       /* After editing .opd, adjust references to opd local syms.  */
2929       long *adjust;
2930     } opd;
2931
2932     /* An array for toc sections, indexed by offset/8.  */
2933     struct _toc_sec_data
2934     {
2935       /* Specifies the relocation symbol index used at a given toc offset.  */
2936       unsigned *symndx;
2937
2938       /* And the relocation addend.  */
2939       bfd_vma *add;
2940     } toc;
2941   } u;
2942
2943   enum _ppc64_sec_type sec_type:2;
2944
2945   /* Flag set when small branches are detected.  Used to
2946      select suitable defaults for the stub group size.  */
2947   unsigned int has_14bit_branch:1;
2948 };
2949
2950 #define ppc64_elf_section_data(sec) \
2951   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2952
2953 static bfd_boolean
2954 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2955 {
2956   if (!sec->used_by_bfd)
2957     {
2958       struct _ppc64_elf_section_data *sdata;
2959       bfd_size_type amt = sizeof (*sdata);
2960
2961       sdata = bfd_zalloc (abfd, amt);
2962       if (sdata == NULL)
2963         return FALSE;
2964       sec->used_by_bfd = sdata;
2965     }
2966
2967   return _bfd_elf_new_section_hook (abfd, sec);
2968 }
2969
2970 static struct _opd_sec_data *
2971 get_opd_info (asection * sec)
2972 {
2973   if (sec != NULL
2974       && ppc64_elf_section_data (sec) != NULL
2975       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2976     return &ppc64_elf_section_data (sec)->u.opd;
2977   return NULL;
2978 }
2979
2980 static inline int
2981 abiversion (bfd *abfd)
2982 {
2983   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2984 }
2985
2986 static inline void
2987 set_abiversion (bfd *abfd, int ver)
2988 {
2989   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2990   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2991 }
2992 \f
2993 /* Parameters for the qsort hook.  */
2994 static bfd_boolean synthetic_relocatable;
2995
2996 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2997
2998 static int
2999 compare_symbols (const void *ap, const void *bp)
3000 {
3001   const asymbol *a = * (const asymbol **) ap;
3002   const asymbol *b = * (const asymbol **) bp;
3003
3004   /* Section symbols first.  */
3005   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3006     return -1;
3007   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3008     return 1;
3009
3010   /* then .opd symbols.  */
3011   if (strcmp (a->section->name, ".opd") == 0
3012       && strcmp (b->section->name, ".opd") != 0)
3013     return -1;
3014   if (strcmp (a->section->name, ".opd") != 0
3015       && strcmp (b->section->name, ".opd") == 0)
3016     return 1;
3017
3018   /* then other code symbols.  */
3019   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3020       == (SEC_CODE | SEC_ALLOC)
3021       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3022          != (SEC_CODE | SEC_ALLOC))
3023     return -1;
3024
3025   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3026       != (SEC_CODE | SEC_ALLOC)
3027       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3028          == (SEC_CODE | SEC_ALLOC))
3029     return 1;
3030
3031   if (synthetic_relocatable)
3032     {
3033       if (a->section->id < b->section->id)
3034         return -1;
3035
3036       if (a->section->id > b->section->id)
3037         return 1;
3038     }
3039
3040   if (a->value + a->section->vma < b->value + b->section->vma)
3041     return -1;
3042
3043   if (a->value + a->section->vma > b->value + b->section->vma)
3044     return 1;
3045
3046   /* For syms with the same value, prefer strong dynamic global function
3047      syms over other syms.  */
3048   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3049     return -1;
3050
3051   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3052     return 1;
3053
3054   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3055     return -1;
3056
3057   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3058     return 1;
3059
3060   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3061     return -1;
3062
3063   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3064     return 1;
3065
3066   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3067     return -1;
3068
3069   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3070     return 1;
3071
3072   return 0;
3073 }
3074
3075 /* Search SYMS for a symbol of the given VALUE.  */
3076
3077 static asymbol *
3078 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3079 {
3080   long mid;
3081
3082   if (id == -1)
3083     {
3084       while (lo < hi)
3085         {
3086           mid = (lo + hi) >> 1;
3087           if (syms[mid]->value + syms[mid]->section->vma < value)
3088             lo = mid + 1;
3089           else if (syms[mid]->value + syms[mid]->section->vma > value)
3090             hi = mid;
3091           else
3092             return syms[mid];
3093         }
3094     }
3095   else
3096     {
3097       while (lo < hi)
3098         {
3099           mid = (lo + hi) >> 1;
3100           if (syms[mid]->section->id < id)
3101             lo = mid + 1;
3102           else if (syms[mid]->section->id > id)
3103             hi = mid;
3104           else if (syms[mid]->value < value)
3105             lo = mid + 1;
3106           else if (syms[mid]->value > value)
3107             hi = mid;
3108           else
3109             return syms[mid];
3110         }
3111     }
3112   return NULL;
3113 }
3114
3115 static bfd_boolean
3116 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3117 {
3118   bfd_vma vma = *(bfd_vma *) ptr;
3119   return ((section->flags & SEC_ALLOC) != 0
3120           && section->vma <= vma
3121           && vma < section->vma + section->size);
3122 }
3123
3124 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3125    entry syms.  Also generate @plt symbols for the glink branch table.  */
3126
3127 static long
3128 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3129                                 long static_count, asymbol **static_syms,
3130                                 long dyn_count, asymbol **dyn_syms,
3131                                 asymbol **ret)
3132 {
3133   asymbol *s;
3134   long i;
3135   long count;
3136   char *names;
3137   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3138   asection *opd = NULL;
3139   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3140   asymbol **syms;
3141   int abi = abiversion (abfd);
3142
3143   *ret = NULL;
3144
3145   if (abi < 2)
3146     {
3147       opd = bfd_get_section_by_name (abfd, ".opd");
3148       if (opd == NULL && abi == 1)
3149         return 0;
3150     }
3151
3152   symcount = static_count;
3153   if (!relocatable)
3154     symcount += dyn_count;
3155   if (symcount == 0)
3156     return 0;
3157
3158   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3159   if (syms == NULL)
3160     return -1;
3161
3162   if (!relocatable && static_count != 0 && dyn_count != 0)
3163     {
3164       /* Use both symbol tables.  */
3165       memcpy (syms, static_syms, static_count * sizeof (*syms));
3166       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3167     }
3168   else if (!relocatable && static_count == 0)
3169     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3170   else
3171     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3172
3173   synthetic_relocatable = relocatable;
3174   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3175
3176   if (!relocatable && symcount > 1)
3177     {
3178       long j;
3179       /* Trim duplicate syms, since we may have merged the normal and
3180          dynamic symbols.  Actually, we only care about syms that have
3181          different values, so trim any with the same value.  */
3182       for (i = 1, j = 1; i < symcount; ++i)
3183         if (syms[i - 1]->value + syms[i - 1]->section->vma
3184             != syms[i]->value + syms[i]->section->vma)
3185           syms[j++] = syms[i];
3186       symcount = j;
3187     }
3188
3189   i = 0;
3190   if (strcmp (syms[i]->section->name, ".opd") == 0)
3191     ++i;
3192   codesecsym = i;
3193
3194   for (; i < symcount; ++i)
3195     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3196          != (SEC_CODE | SEC_ALLOC))
3197         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3198       break;
3199   codesecsymend = i;
3200
3201   for (; i < symcount; ++i)
3202     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3203       break;
3204   secsymend = i;
3205
3206   for (; i < symcount; ++i)
3207     if (strcmp (syms[i]->section->name, ".opd") != 0)
3208       break;
3209   opdsymend = i;
3210
3211   for (; i < symcount; ++i)
3212     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3213         != (SEC_CODE | SEC_ALLOC))
3214       break;
3215   symcount = i;
3216
3217   count = 0;
3218
3219   if (relocatable)
3220     {
3221       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3222       arelent *r;
3223       size_t size;
3224       long relcount;
3225
3226       if (opdsymend == secsymend)
3227         goto done;
3228
3229       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3230       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3231       if (relcount == 0)
3232         goto done;
3233
3234       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3235         {
3236           count = -1;
3237           goto done;
3238         }
3239
3240       size = 0;
3241       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3242         {
3243           asymbol *sym;
3244
3245           while (r < opd->relocation + relcount
3246                  && r->address < syms[i]->value + opd->vma)
3247             ++r;
3248
3249           if (r == opd->relocation + relcount)
3250             break;
3251
3252           if (r->address != syms[i]->value + opd->vma)
3253             continue;
3254
3255           if (r->howto->type != R_PPC64_ADDR64)
3256             continue;
3257
3258           sym = *r->sym_ptr_ptr;
3259           if (!sym_exists_at (syms, opdsymend, symcount,
3260                               sym->section->id, sym->value + r->addend))
3261             {
3262               ++count;
3263               size += sizeof (asymbol);
3264               size += strlen (syms[i]->name) + 2;
3265             }
3266         }
3267
3268       s = *ret = bfd_malloc (size);
3269       if (s == NULL)
3270         {
3271           count = -1;
3272           goto done;
3273         }
3274
3275       names = (char *) (s + count);
3276
3277       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3278         {
3279           asymbol *sym;
3280
3281           while (r < opd->relocation + relcount
3282                  && r->address < syms[i]->value + opd->vma)
3283             ++r;
3284
3285           if (r == opd->relocation + relcount)
3286             break;
3287
3288           if (r->address != syms[i]->value + opd->vma)
3289             continue;
3290
3291           if (r->howto->type != R_PPC64_ADDR64)
3292             continue;
3293
3294           sym = *r->sym_ptr_ptr;
3295           if (!sym_exists_at (syms, opdsymend, symcount,
3296                               sym->section->id, sym->value + r->addend))
3297             {
3298               size_t len;
3299
3300               *s = *syms[i];
3301               s->flags |= BSF_SYNTHETIC;
3302               s->section = sym->section;
3303               s->value = sym->value + r->addend;
3304               s->name = names;
3305               *names++ = '.';
3306               len = strlen (syms[i]->name);
3307               memcpy (names, syms[i]->name, len + 1);
3308               names += len + 1;
3309               /* Have udata.p point back to the original symbol this
3310                  synthetic symbol was derived from.  */
3311               s->udata.p = syms[i];
3312               s++;
3313             }
3314         }
3315     }
3316   else
3317     {
3318       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3319       bfd_byte *contents = NULL;
3320       size_t size;
3321       long plt_count = 0;
3322       bfd_vma glink_vma = 0, resolv_vma = 0;
3323       asection *dynamic, *glink = NULL, *relplt = NULL;
3324       arelent *p;
3325
3326       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3327         {
3328         free_contents_and_exit:
3329           if (contents)
3330             free (contents);
3331           count = -1;
3332           goto done;
3333         }
3334
3335       size = 0;
3336       for (i = secsymend; i < opdsymend; ++i)
3337         {
3338           bfd_vma ent;
3339
3340           /* Ignore bogus symbols.  */
3341           if (syms[i]->value > opd->size - 8)
3342             continue;
3343
3344           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3345           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3346             {
3347               ++count;
3348               size += sizeof (asymbol);
3349               size += strlen (syms[i]->name) + 2;
3350             }
3351         }
3352
3353       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3354       if (dyn_count != 0
3355           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3356         {
3357           bfd_byte *dynbuf, *extdyn, *extdynend;
3358           size_t extdynsize;
3359           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3360
3361           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3362             goto free_contents_and_exit;
3363
3364           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3365           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3366
3367           extdyn = dynbuf;
3368           extdynend = extdyn + dynamic->size;
3369           for (; extdyn < extdynend; extdyn += extdynsize)
3370             {
3371               Elf_Internal_Dyn dyn;
3372               (*swap_dyn_in) (abfd, extdyn, &dyn);
3373
3374               if (dyn.d_tag == DT_NULL)
3375                 break;
3376
3377               if (dyn.d_tag == DT_PPC64_GLINK)
3378                 {
3379                   /* The first glink stub starts at offset 32; see
3380                      comment in ppc64_elf_finish_dynamic_sections. */
3381                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3382                   /* The .glink section usually does not survive the final
3383                      link; search for the section (usually .text) where the
3384                      glink stubs now reside.  */
3385                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3386                                                 &glink_vma);
3387                   break;
3388                 }
3389             }
3390
3391           free (dynbuf);
3392         }
3393
3394       if (glink != NULL)
3395         {
3396           /* Determine __glink trampoline by reading the relative branch
3397              from the first glink stub.  */
3398           bfd_byte buf[4];
3399           unsigned int off = 0;
3400
3401           while (bfd_get_section_contents (abfd, glink, buf,
3402                                            glink_vma + off - glink->vma, 4))
3403             {
3404               unsigned int insn = bfd_get_32 (abfd, buf);
3405               insn ^= B_DOT;
3406               if ((insn & ~0x3fffffc) == 0)
3407                 {
3408                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3409                   break;
3410                 }
3411               off += 4;
3412               if (off > 4)
3413                 break;
3414             }
3415
3416           if (resolv_vma)
3417             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3418
3419           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3420           if (relplt != NULL)
3421             {
3422               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3423               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3424                 goto free_contents_and_exit;
3425
3426               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3427               size += plt_count * sizeof (asymbol);
3428
3429               p = relplt->relocation;
3430               for (i = 0; i < plt_count; i++, p++)
3431                 {
3432                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3433                   if (p->addend != 0)
3434                     size += sizeof ("+0x") - 1 + 16;
3435                 }
3436             }
3437         }
3438
3439       s = *ret = bfd_malloc (size);
3440       if (s == NULL)
3441         goto free_contents_and_exit;
3442
3443       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3444
3445       for (i = secsymend; i < opdsymend; ++i)
3446         {
3447           bfd_vma ent;
3448
3449           if (syms[i]->value > opd->size - 8)
3450             continue;
3451
3452           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3453           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3454             {
3455               long lo, hi;
3456               size_t len;
3457               asection *sec = abfd->sections;
3458
3459               *s = *syms[i];
3460               lo = codesecsym;
3461               hi = codesecsymend;
3462               while (lo < hi)
3463                 {
3464                   long mid = (lo + hi) >> 1;
3465                   if (syms[mid]->section->vma < ent)
3466                     lo = mid + 1;
3467                   else if (syms[mid]->section->vma > ent)
3468                     hi = mid;
3469                   else
3470                     {
3471                       sec = syms[mid]->section;
3472                       break;
3473                     }
3474                 }
3475
3476               if (lo >= hi && lo > codesecsym)
3477                 sec = syms[lo - 1]->section;
3478
3479               for (; sec != NULL; sec = sec->next)
3480                 {
3481                   if (sec->vma > ent)
3482                     break;
3483                   /* SEC_LOAD may not be set if SEC is from a separate debug
3484                      info file.  */
3485                   if ((sec->flags & SEC_ALLOC) == 0)
3486                     break;
3487                   if ((sec->flags & SEC_CODE) != 0)
3488                     s->section = sec;
3489                 }
3490               s->flags |= BSF_SYNTHETIC;
3491               s->value = ent - s->section->vma;
3492               s->name = names;
3493               *names++ = '.';
3494               len = strlen (syms[i]->name);
3495               memcpy (names, syms[i]->name, len + 1);
3496               names += len + 1;
3497               /* Have udata.p point back to the original symbol this
3498                  synthetic symbol was derived from.  */
3499               s->udata.p = syms[i];
3500               s++;
3501             }
3502         }
3503       free (contents);
3504
3505       if (glink != NULL && relplt != NULL)
3506         {
3507           if (resolv_vma)
3508             {
3509               /* Add a symbol for the main glink trampoline.  */
3510               memset (s, 0, sizeof *s);
3511               s->the_bfd = abfd;
3512               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3513               s->section = glink;
3514               s->value = resolv_vma - glink->vma;
3515               s->name = names;
3516               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3517               names += sizeof ("__glink_PLTresolve");
3518               s++;
3519               count++;
3520             }
3521
3522           /* FIXME: It would be very much nicer to put sym@plt on the
3523              stub rather than on the glink branch table entry.  The
3524              objdump disassembler would then use a sensible symbol
3525              name on plt calls.  The difficulty in doing so is
3526              a) finding the stubs, and,
3527              b) matching stubs against plt entries, and,
3528              c) there can be multiple stubs for a given plt entry.
3529
3530              Solving (a) could be done by code scanning, but older
3531              ppc64 binaries used different stubs to current code.
3532              (b) is the tricky one since you need to known the toc
3533              pointer for at least one function that uses a pic stub to
3534              be able to calculate the plt address referenced.
3535              (c) means gdb would need to set multiple breakpoints (or
3536              find the glink branch itself) when setting breakpoints
3537              for pending shared library loads.  */
3538           p = relplt->relocation;
3539           for (i = 0; i < plt_count; i++, p++)
3540             {
3541               size_t len;
3542
3543               *s = **p->sym_ptr_ptr;
3544               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3545                  we are defining a symbol, ensure one of them is set.  */
3546               if ((s->flags & BSF_LOCAL) == 0)
3547                 s->flags |= BSF_GLOBAL;
3548               s->flags |= BSF_SYNTHETIC;
3549               s->section = glink;
3550               s->value = glink_vma - glink->vma;
3551               s->name = names;
3552               s->udata.p = NULL;
3553               len = strlen ((*p->sym_ptr_ptr)->name);
3554               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3555               names += len;
3556               if (p->addend != 0)
3557                 {
3558                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3559                   names += sizeof ("+0x") - 1;
3560                   bfd_sprintf_vma (abfd, names, p->addend);
3561                   names += strlen (names);
3562                 }
3563               memcpy (names, "@plt", sizeof ("@plt"));
3564               names += sizeof ("@plt");
3565               s++;
3566               if (abi < 2)
3567                 {
3568                   glink_vma += 8;
3569                   if (i >= 0x8000)
3570                     glink_vma += 4;
3571                 }
3572               else
3573                 glink_vma += 4;
3574             }
3575           count += plt_count;
3576         }
3577     }
3578
3579  done:
3580   free (syms);
3581   return count;
3582 }
3583 \f
3584 /* The following functions are specific to the ELF linker, while
3585    functions above are used generally.  Those named ppc64_elf_* are
3586    called by the main ELF linker code.  They appear in this file more
3587    or less in the order in which they are called.  eg.
3588    ppc64_elf_check_relocs is called early in the link process,
3589    ppc64_elf_finish_dynamic_sections is one of the last functions
3590    called.
3591
3592    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3593    functions have both a function code symbol and a function descriptor
3594    symbol.  A call to foo in a relocatable object file looks like:
3595
3596    .            .text
3597    .    x:
3598    .            bl      .foo
3599    .            nop
3600
3601    The function definition in another object file might be:
3602
3603    .            .section .opd
3604    .    foo:    .quad   .foo
3605    .            .quad   .TOC.@tocbase
3606    .            .quad   0
3607    .
3608    .            .text
3609    .    .foo:   blr
3610
3611    When the linker resolves the call during a static link, the branch
3612    unsurprisingly just goes to .foo and the .opd information is unused.
3613    If the function definition is in a shared library, things are a little
3614    different:  The call goes via a plt call stub, the opd information gets
3615    copied to the plt, and the linker patches the nop.
3616
3617    .    x:
3618    .            bl      .foo_stub
3619    .            ld      2,40(1)
3620    .
3621    .
3622    .    .foo_stub:
3623    .            std     2,40(1)                 # in practice, the call stub
3624    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3625    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3626    .            ld      12,0(11)
3627    .            ld      2,8(11)
3628    .            mtctr   12
3629    .            ld      11,16(11)
3630    .            bctr
3631    .
3632    .            .section .plt
3633    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3634
3635    The "reloc ()" notation is supposed to indicate that the linker emits
3636    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3637    copying.
3638
3639    What are the difficulties here?  Well, firstly, the relocations
3640    examined by the linker in check_relocs are against the function code
3641    sym .foo, while the dynamic relocation in the plt is emitted against
3642    the function descriptor symbol, foo.  Somewhere along the line, we need
3643    to carefully copy dynamic link information from one symbol to the other.
3644    Secondly, the generic part of the elf linker will make .foo a dynamic
3645    symbol as is normal for most other backends.  We need foo dynamic
3646    instead, at least for an application final link.  However, when
3647    creating a shared library containing foo, we need to have both symbols
3648    dynamic so that references to .foo are satisfied during the early
3649    stages of linking.  Otherwise the linker might decide to pull in a
3650    definition from some other object, eg. a static library.
3651
3652    Update: As of August 2004, we support a new convention.  Function
3653    calls may use the function descriptor symbol, ie. "bl foo".  This
3654    behaves exactly as "bl .foo".  */
3655
3656 /* Of those relocs that might be copied as dynamic relocs, this function
3657    selects those that must be copied when linking a shared library,
3658    even when the symbol is local.  */
3659
3660 static int
3661 must_be_dyn_reloc (struct bfd_link_info *info,
3662                    enum elf_ppc64_reloc_type r_type)
3663 {
3664   switch (r_type)
3665     {
3666     default:
3667       return 1;
3668
3669     case R_PPC64_REL32:
3670     case R_PPC64_REL64:
3671     case R_PPC64_REL30:
3672       return 0;
3673
3674     case R_PPC64_TPREL16:
3675     case R_PPC64_TPREL16_LO:
3676     case R_PPC64_TPREL16_HI:
3677     case R_PPC64_TPREL16_HA:
3678     case R_PPC64_TPREL16_DS:
3679     case R_PPC64_TPREL16_LO_DS:
3680     case R_PPC64_TPREL16_HIGH:
3681     case R_PPC64_TPREL16_HIGHA:
3682     case R_PPC64_TPREL16_HIGHER:
3683     case R_PPC64_TPREL16_HIGHERA:
3684     case R_PPC64_TPREL16_HIGHEST:
3685     case R_PPC64_TPREL16_HIGHESTA:
3686     case R_PPC64_TPREL64:
3687       return !info->executable;
3688     }
3689 }
3690
3691 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3692    copying dynamic variables from a shared lib into an app's dynbss
3693    section, and instead use a dynamic relocation to point into the
3694    shared lib.  With code that gcc generates, it's vital that this be
3695    enabled;  In the PowerPC64 ABI, the address of a function is actually
3696    the address of a function descriptor, which resides in the .opd
3697    section.  gcc uses the descriptor directly rather than going via the
3698    GOT as some other ABI's do, which means that initialized function
3699    pointers must reference the descriptor.  Thus, a function pointer
3700    initialized to the address of a function in a shared library will
3701    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3702    redefines the function descriptor symbol to point to the copy.  This
3703    presents a problem as a plt entry for that function is also
3704    initialized from the function descriptor symbol and the copy reloc
3705    may not be initialized first.  */
3706 #define ELIMINATE_COPY_RELOCS 1
3707
3708 /* Section name for stubs is the associated section name plus this
3709    string.  */
3710 #define STUB_SUFFIX ".stub"
3711
3712 /* Linker stubs.
3713    ppc_stub_long_branch:
3714    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3715    destination, but a 24 bit branch in a stub section will reach.
3716    .    b       dest
3717
3718    ppc_stub_plt_branch:
3719    Similar to the above, but a 24 bit branch in the stub section won't
3720    reach its destination.
3721    .    addis   %r11,%r2,xxx@toc@ha
3722    .    ld      %r12,xxx@toc@l(%r11)
3723    .    mtctr   %r12
3724    .    bctr
3725
3726    ppc_stub_plt_call:
3727    Used to call a function in a shared library.  If it so happens that
3728    the plt entry referenced crosses a 64k boundary, then an extra
3729    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3730    .    std     %r2,40(%r1)
3731    .    addis   %r11,%r2,xxx@toc@ha
3732    .    ld      %r12,xxx+0@toc@l(%r11)
3733    .    mtctr   %r12
3734    .    ld      %r2,xxx+8@toc@l(%r11)
3735    .    ld      %r11,xxx+16@toc@l(%r11)
3736    .    bctr
3737
3738    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3739    code to adjust the value and save r2 to support multiple toc sections.
3740    A ppc_stub_long_branch with an r2 offset looks like:
3741    .    std     %r2,40(%r1)
3742    .    addis   %r2,%r2,off@ha
3743    .    addi    %r2,%r2,off@l
3744    .    b       dest
3745
3746    A ppc_stub_plt_branch with an r2 offset looks like:
3747    .    std     %r2,40(%r1)
3748    .    addis   %r11,%r2,xxx@toc@ha
3749    .    ld      %r12,xxx@toc@l(%r11)
3750    .    addis   %r2,%r2,off@ha
3751    .    addi    %r2,%r2,off@l
3752    .    mtctr   %r12
3753    .    bctr
3754
3755    In cases where the "addis" instruction would add zero, the "addis" is
3756    omitted and following instructions modified slightly in some cases.
3757 */
3758
3759 enum ppc_stub_type {
3760   ppc_stub_none,
3761   ppc_stub_long_branch,
3762   ppc_stub_long_branch_r2off,
3763   ppc_stub_plt_branch,
3764   ppc_stub_plt_branch_r2off,
3765   ppc_stub_plt_call,
3766   ppc_stub_plt_call_r2save
3767 };
3768
3769 struct ppc_stub_hash_entry {
3770
3771   /* Base hash table entry structure.  */
3772   struct bfd_hash_entry root;
3773
3774   enum ppc_stub_type stub_type;
3775
3776   /* The stub section.  */
3777   asection *stub_sec;
3778
3779   /* Offset within stub_sec of the beginning of this stub.  */
3780   bfd_vma stub_offset;
3781
3782   /* Given the symbol's value and its section we can determine its final
3783      value when building the stubs (so the stub knows where to jump.  */
3784   bfd_vma target_value;
3785   asection *target_section;
3786
3787   /* The symbol table entry, if any, that this was derived from.  */
3788   struct ppc_link_hash_entry *h;
3789   struct plt_entry *plt_ent;
3790
3791   /* Where this stub is being called from, or, in the case of combined
3792      stub sections, the first input section in the group.  */
3793   asection *id_sec;
3794
3795   /* Symbol st_other.  */
3796   unsigned char other;
3797 };
3798
3799 struct ppc_branch_hash_entry {
3800
3801   /* Base hash table entry structure.  */
3802   struct bfd_hash_entry root;
3803
3804   /* Offset within branch lookup table.  */
3805   unsigned int offset;
3806
3807   /* Generation marker.  */
3808   unsigned int iter;
3809 };
3810
3811 /* Used to track dynamic relocations for local symbols.  */
3812 struct ppc_dyn_relocs
3813 {
3814   struct ppc_dyn_relocs *next;
3815
3816   /* The input section of the reloc.  */
3817   asection *sec;
3818
3819   /* Total number of relocs copied for the input section.  */
3820   unsigned int count : 31;
3821
3822   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3823   unsigned int ifunc : 1;
3824 };
3825
3826 struct ppc_link_hash_entry
3827 {
3828   struct elf_link_hash_entry elf;
3829
3830   union {
3831     /* A pointer to the most recently used stub hash entry against this
3832        symbol.  */
3833     struct ppc_stub_hash_entry *stub_cache;
3834
3835     /* A pointer to the next symbol starting with a '.'  */
3836     struct ppc_link_hash_entry *next_dot_sym;
3837   } u;
3838
3839   /* Track dynamic relocs copied for this symbol.  */
3840   struct elf_dyn_relocs *dyn_relocs;
3841
3842   /* Link between function code and descriptor symbols.  */
3843   struct ppc_link_hash_entry *oh;
3844
3845   /* Flag function code and descriptor symbols.  */
3846   unsigned int is_func:1;
3847   unsigned int is_func_descriptor:1;
3848   unsigned int fake:1;
3849
3850   /* Whether global opd/toc sym has been adjusted or not.
3851      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3852      should be set for all globals defined in any opd/toc section.  */
3853   unsigned int adjust_done:1;
3854
3855   /* Set if we twiddled this symbol to weak at some stage.  */
3856   unsigned int was_undefined:1;
3857
3858   /* Contexts in which symbol is used in the GOT (or TOC).
3859      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3860      corresponding relocs are encountered during check_relocs.
3861      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3862      indicate the corresponding GOT entry type is not needed.
3863      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3864      a TPREL one.  We use a separate flag rather than setting TPREL
3865      just for convenience in distinguishing the two cases.  */
3866 #define TLS_GD           1      /* GD reloc. */
3867 #define TLS_LD           2      /* LD reloc. */
3868 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3869 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3870 #define TLS_TLS         16      /* Any TLS reloc.  */
3871 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3872 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3873 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3874   unsigned char tls_mask;
3875 };
3876
3877 /* ppc64 ELF linker hash table.  */
3878
3879 struct ppc_link_hash_table
3880 {
3881   struct elf_link_hash_table elf;
3882
3883   /* The stub hash table.  */
3884   struct bfd_hash_table stub_hash_table;
3885
3886   /* Another hash table for plt_branch stubs.  */
3887   struct bfd_hash_table branch_hash_table;
3888
3889   /* Hash table for function prologue tocsave.  */
3890   htab_t tocsave_htab;
3891
3892   /* Various options and other info passed from the linker.  */
3893   struct ppc64_elf_params *params;
3894
3895   /* Array to keep track of which stub sections have been created, and
3896      information on stub grouping.  */
3897   struct map_stub {
3898     /* This is the section to which stubs in the group will be attached.  */
3899     asection *link_sec;
3900     /* The stub section.  */
3901     asection *stub_sec;
3902     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3903     bfd_vma toc_off;
3904   } *stub_group;
3905
3906   /* Temp used when calculating TOC pointers.  */
3907   bfd_vma toc_curr;
3908   bfd *toc_bfd;
3909   asection *toc_first_sec;
3910
3911   /* Highest input section id.  */
3912   int top_id;
3913
3914   /* Highest output section index.  */
3915   int top_index;
3916
3917   /* Used when adding symbols.  */
3918   struct ppc_link_hash_entry *dot_syms;
3919
3920   /* List of input sections for each output section.  */
3921   asection **input_list;
3922
3923   /* Shortcuts to get to dynamic linker sections.  */
3924   asection *dynbss;
3925   asection *relbss;
3926   asection *glink;
3927   asection *sfpr;
3928   asection *brlt;
3929   asection *relbrlt;
3930   asection *glink_eh_frame;
3931
3932   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3933   struct ppc_link_hash_entry *tls_get_addr;
3934   struct ppc_link_hash_entry *tls_get_addr_fd;
3935
3936   /* The size of reliplt used by got entry relocs.  */
3937   bfd_size_type got_reli_size;
3938
3939   /* Statistics.  */
3940   unsigned long stub_count[ppc_stub_plt_call_r2save];
3941
3942   /* Number of stubs against global syms.  */
3943   unsigned long stub_globals;
3944
3945   /* Set if we're linking code with function descriptors.  */
3946   unsigned int opd_abi:1;
3947
3948   /* Support for multiple toc sections.  */
3949   unsigned int do_multi_toc:1;
3950   unsigned int multi_toc_needed:1;
3951   unsigned int second_toc_pass:1;
3952   unsigned int do_toc_opt:1;
3953
3954   /* Set on error.  */
3955   unsigned int stub_error:1;
3956
3957   /* Temp used by ppc64_elf_process_dot_syms.  */
3958   unsigned int twiddled_syms:1;
3959
3960   /* Incremented every time we size stubs.  */
3961   unsigned int stub_iteration;
3962
3963   /* Small local sym cache.  */
3964   struct sym_cache sym_cache;
3965 };
3966
3967 /* Rename some of the generic section flags to better document how they
3968    are used here.  */
3969
3970 /* Nonzero if this section has TLS related relocations.  */
3971 #define has_tls_reloc sec_flg0
3972
3973 /* Nonzero if this section has a call to __tls_get_addr.  */
3974 #define has_tls_get_addr_call sec_flg1
3975
3976 /* Nonzero if this section has any toc or got relocs.  */
3977 #define has_toc_reloc sec_flg2
3978
3979 /* Nonzero if this section has a call to another section that uses
3980    the toc or got.  */
3981 #define makes_toc_func_call sec_flg3
3982
3983 /* Recursion protection when determining above flag.  */
3984 #define call_check_in_progress sec_flg4
3985 #define call_check_done sec_flg5
3986
3987 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3988
3989 #define ppc_hash_table(p) \
3990   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3991   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3992
3993 #define ppc_stub_hash_lookup(table, string, create, copy) \
3994   ((struct ppc_stub_hash_entry *) \
3995    bfd_hash_lookup ((table), (string), (create), (copy)))
3996
3997 #define ppc_branch_hash_lookup(table, string, create, copy) \
3998   ((struct ppc_branch_hash_entry *) \
3999    bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001 /* Create an entry in the stub hash table.  */
4002
4003 static struct bfd_hash_entry *
4004 stub_hash_newfunc (struct bfd_hash_entry *entry,
4005                    struct bfd_hash_table *table,
4006                    const char *string)
4007 {
4008   /* Allocate the structure if it has not already been allocated by a
4009      subclass.  */
4010   if (entry == NULL)
4011     {
4012       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4013       if (entry == NULL)
4014         return entry;
4015     }
4016
4017   /* Call the allocation method of the superclass.  */
4018   entry = bfd_hash_newfunc (entry, table, string);
4019   if (entry != NULL)
4020     {
4021       struct ppc_stub_hash_entry *eh;
4022
4023       /* Initialize the local fields.  */
4024       eh = (struct ppc_stub_hash_entry *) entry;
4025       eh->stub_type = ppc_stub_none;
4026       eh->stub_sec = NULL;
4027       eh->stub_offset = 0;
4028       eh->target_value = 0;
4029       eh->target_section = NULL;
4030       eh->h = NULL;
4031       eh->plt_ent = NULL;
4032       eh->id_sec = NULL;
4033       eh->other = 0;
4034     }
4035
4036   return entry;
4037 }
4038
4039 /* Create an entry in the branch hash table.  */
4040
4041 static struct bfd_hash_entry *
4042 branch_hash_newfunc (struct bfd_hash_entry *entry,
4043                      struct bfd_hash_table *table,
4044                      const char *string)
4045 {
4046   /* Allocate the structure if it has not already been allocated by a
4047      subclass.  */
4048   if (entry == NULL)
4049     {
4050       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4051       if (entry == NULL)
4052         return entry;
4053     }
4054
4055   /* Call the allocation method of the superclass.  */
4056   entry = bfd_hash_newfunc (entry, table, string);
4057   if (entry != NULL)
4058     {
4059       struct ppc_branch_hash_entry *eh;
4060
4061       /* Initialize the local fields.  */
4062       eh = (struct ppc_branch_hash_entry *) entry;
4063       eh->offset = 0;
4064       eh->iter = 0;
4065     }
4066
4067   return entry;
4068 }
4069
4070 /* Create an entry in a ppc64 ELF linker hash table.  */
4071
4072 static struct bfd_hash_entry *
4073 link_hash_newfunc (struct bfd_hash_entry *entry,
4074                    struct bfd_hash_table *table,
4075                    const char *string)
4076 {
4077   /* Allocate the structure if it has not already been allocated by a
4078      subclass.  */
4079   if (entry == NULL)
4080     {
4081       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4082       if (entry == NULL)
4083         return entry;
4084     }
4085
4086   /* Call the allocation method of the superclass.  */
4087   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4088   if (entry != NULL)
4089     {
4090       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4091
4092       memset (&eh->u.stub_cache, 0,
4093               (sizeof (struct ppc_link_hash_entry)
4094                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4095
4096       /* When making function calls, old ABI code references function entry
4097          points (dot symbols), while new ABI code references the function
4098          descriptor symbol.  We need to make any combination of reference and
4099          definition work together, without breaking archive linking.
4100
4101          For a defined function "foo" and an undefined call to "bar":
4102          An old object defines "foo" and ".foo", references ".bar" (possibly
4103          "bar" too).
4104          A new object defines "foo" and references "bar".
4105
4106          A new object thus has no problem with its undefined symbols being
4107          satisfied by definitions in an old object.  On the other hand, the
4108          old object won't have ".bar" satisfied by a new object.
4109
4110          Keep a list of newly added dot-symbols.  */
4111
4112       if (string[0] == '.')
4113         {
4114           struct ppc_link_hash_table *htab;
4115
4116           htab = (struct ppc_link_hash_table *) table;
4117           eh->u.next_dot_sym = htab->dot_syms;
4118           htab->dot_syms = eh;
4119         }
4120     }
4121
4122   return entry;
4123 }
4124
4125 struct tocsave_entry {
4126   asection *sec;
4127   bfd_vma offset;
4128 };
4129
4130 static hashval_t
4131 tocsave_htab_hash (const void *p)
4132 {
4133   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4134   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4135 }
4136
4137 static int
4138 tocsave_htab_eq (const void *p1, const void *p2)
4139 {
4140   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4141   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4142   return e1->sec == e2->sec && e1->offset == e2->offset;
4143 }
4144
4145 /* Create a ppc64 ELF linker hash table.  */
4146
4147 static struct bfd_link_hash_table *
4148 ppc64_elf_link_hash_table_create (bfd *abfd)
4149 {
4150   struct ppc_link_hash_table *htab;
4151   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4152
4153   htab = bfd_zmalloc (amt);
4154   if (htab == NULL)
4155     return NULL;
4156
4157   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4158                                       sizeof (struct ppc_link_hash_entry),
4159                                       PPC64_ELF_DATA))
4160     {
4161       free (htab);
4162       return NULL;
4163     }
4164
4165   /* Init the stub hash table too.  */
4166   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4167                             sizeof (struct ppc_stub_hash_entry)))
4168     {
4169       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4170       return NULL;
4171     }
4172
4173   /* And the branch hash table.  */
4174   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175                             sizeof (struct ppc_branch_hash_entry)))
4176     {
4177       bfd_hash_table_free (&htab->stub_hash_table);
4178       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4179       return NULL;
4180     }
4181
4182   htab->tocsave_htab = htab_try_create (1024,
4183                                         tocsave_htab_hash,
4184                                         tocsave_htab_eq,
4185                                         NULL);
4186   if (htab->tocsave_htab == NULL)
4187     {
4188       bfd_hash_table_free (&htab->branch_hash_table);
4189       bfd_hash_table_free (&htab->stub_hash_table);
4190       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4191       return NULL;
4192     }
4193
4194   /* Initializing two fields of the union is just cosmetic.  We really
4195      only care about glist, but when compiled on a 32-bit host the
4196      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4197      debugger inspection of these fields look nicer.  */
4198   htab->elf.init_got_refcount.refcount = 0;
4199   htab->elf.init_got_refcount.glist = NULL;
4200   htab->elf.init_plt_refcount.refcount = 0;
4201   htab->elf.init_plt_refcount.glist = NULL;
4202   htab->elf.init_got_offset.offset = 0;
4203   htab->elf.init_got_offset.glist = NULL;
4204   htab->elf.init_plt_offset.offset = 0;
4205   htab->elf.init_plt_offset.glist = NULL;
4206
4207   return &htab->elf.root;
4208 }
4209
4210 /* Free the derived linker hash table.  */
4211
4212 static void
4213 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4214 {
4215   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4216
4217   bfd_hash_table_free (&htab->stub_hash_table);
4218   bfd_hash_table_free (&htab->branch_hash_table);
4219   if (htab->tocsave_htab)
4220     htab_delete (htab->tocsave_htab);
4221   _bfd_elf_link_hash_table_free (hash);
4222 }
4223
4224 /* Create sections for linker generated code.  */
4225
4226 static bfd_boolean
4227 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4228 {
4229   struct ppc_link_hash_table *htab;
4230   flagword flags;
4231
4232   htab = ppc_hash_table (info);
4233
4234   /* Create .sfpr for code to save and restore fp regs.  */
4235   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4236            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4237   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4238                                                    flags);
4239   if (htab->sfpr == NULL
4240       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4241     return FALSE;
4242
4243   /* Create .glink for lazy dynamic linking support.  */
4244   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4245                                                     flags);
4246   if (htab->glink == NULL
4247       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4248     return FALSE;
4249
4250   if (!info->no_ld_generated_unwind_info)
4251     {
4252       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4253                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4254       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4255                                                                  ".eh_frame",
4256                                                                  flags);
4257       if (htab->glink_eh_frame == NULL
4258           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4259         return FALSE;
4260     }
4261
4262   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4263   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4264   if (htab->elf.iplt == NULL
4265       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4266     return FALSE;
4267
4268   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4269            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->elf.irelplt
4271     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4272   if (htab->elf.irelplt == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4274     return FALSE;
4275
4276   /* Create branch lookup table for plt_branch stubs.  */
4277   flags = (SEC_ALLOC | SEC_LOAD
4278            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4279   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4280                                                    flags);
4281   if (htab->brlt == NULL
4282       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4283     return FALSE;
4284
4285   if (!info->shared)
4286     return TRUE;
4287
4288   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4289            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4290   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4291                                                       ".rela.branch_lt",
4292                                                       flags);
4293   if (htab->relbrlt == NULL
4294       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4295     return FALSE;
4296
4297   return TRUE;
4298 }
4299
4300 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4301
4302 bfd_boolean
4303 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4304                          struct ppc64_elf_params *params)
4305 {
4306   struct ppc_link_hash_table *htab;
4307
4308   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4309
4310 /* Always hook our dynamic sections into the first bfd, which is the
4311    linker created stub bfd.  This ensures that the GOT header is at
4312    the start of the output TOC section.  */
4313   htab = ppc_hash_table (info);
4314   if (htab == NULL)
4315     return FALSE;
4316   htab->elf.dynobj = params->stub_bfd;
4317   htab->params = params;
4318
4319   if (info->relocatable)
4320     return TRUE;
4321
4322   return create_linkage_sections (htab->elf.dynobj, info);
4323 }
4324
4325 /* Build a name for an entry in the stub hash table.  */
4326
4327 static char *
4328 ppc_stub_name (const asection *input_section,
4329                const asection *sym_sec,
4330                const struct ppc_link_hash_entry *h,
4331                const Elf_Internal_Rela *rel)
4332 {
4333   char *stub_name;
4334   ssize_t len;
4335
4336   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4337      offsets from a sym as a branch target?  In fact, we could
4338      probably assume the addend is always zero.  */
4339   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4340
4341   if (h)
4342     {
4343       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4344       stub_name = bfd_malloc (len);
4345       if (stub_name == NULL)
4346         return stub_name;
4347
4348       len = sprintf (stub_name, "%08x.%s+%x",
4349                      input_section->id & 0xffffffff,
4350                      h->elf.root.root.string,
4351                      (int) rel->r_addend & 0xffffffff);
4352     }
4353   else
4354     {
4355       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4356       stub_name = bfd_malloc (len);
4357       if (stub_name == NULL)
4358         return stub_name;
4359
4360       len = sprintf (stub_name, "%08x.%x:%x+%x",
4361                      input_section->id & 0xffffffff,
4362                      sym_sec->id & 0xffffffff,
4363                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4364                      (int) rel->r_addend & 0xffffffff);
4365     }
4366   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4367     stub_name[len - 2] = 0;
4368   return stub_name;
4369 }
4370
4371 /* Look up an entry in the stub hash.  Stub entries are cached because
4372    creating the stub name takes a bit of time.  */
4373
4374 static struct ppc_stub_hash_entry *
4375 ppc_get_stub_entry (const asection *input_section,
4376                     const asection *sym_sec,
4377                     struct ppc_link_hash_entry *h,
4378                     const Elf_Internal_Rela *rel,
4379                     struct ppc_link_hash_table *htab)
4380 {
4381   struct ppc_stub_hash_entry *stub_entry;
4382   const asection *id_sec;
4383
4384   /* If this input section is part of a group of sections sharing one
4385      stub section, then use the id of the first section in the group.
4386      Stub names need to include a section id, as there may well be
4387      more than one stub used to reach say, printf, and we need to
4388      distinguish between them.  */
4389   id_sec = htab->stub_group[input_section->id].link_sec;
4390
4391   if (h != NULL && h->u.stub_cache != NULL
4392       && h->u.stub_cache->h == h
4393       && h->u.stub_cache->id_sec == id_sec)
4394     {
4395       stub_entry = h->u.stub_cache;
4396     }
4397   else
4398     {
4399       char *stub_name;
4400
4401       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4402       if (stub_name == NULL)
4403         return NULL;
4404
4405       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4406                                          stub_name, FALSE, FALSE);
4407       if (h != NULL)
4408         h->u.stub_cache = stub_entry;
4409
4410       free (stub_name);
4411     }
4412
4413   return stub_entry;
4414 }
4415
4416 /* Add a new stub entry to the stub hash.  Not all fields of the new
4417    stub entry are initialised.  */
4418
4419 static struct ppc_stub_hash_entry *
4420 ppc_add_stub (const char *stub_name,
4421               asection *section,
4422               struct bfd_link_info *info)
4423 {
4424   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4425   asection *link_sec;
4426   asection *stub_sec;
4427   struct ppc_stub_hash_entry *stub_entry;
4428
4429   link_sec = htab->stub_group[section->id].link_sec;
4430   stub_sec = htab->stub_group[section->id].stub_sec;
4431   if (stub_sec == NULL)
4432     {
4433       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4434       if (stub_sec == NULL)
4435         {
4436           size_t namelen;
4437           bfd_size_type len;
4438           char *s_name;
4439
4440           namelen = strlen (link_sec->name);
4441           len = namelen + sizeof (STUB_SUFFIX);
4442           s_name = bfd_alloc (htab->params->stub_bfd, len);
4443           if (s_name == NULL)
4444             return NULL;
4445
4446           memcpy (s_name, link_sec->name, namelen);
4447           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4448           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4449           if (stub_sec == NULL)
4450             return NULL;
4451           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4452         }
4453       htab->stub_group[section->id].stub_sec = stub_sec;
4454     }
4455
4456   /* Enter this entry into the linker stub hash table.  */
4457   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4458                                      TRUE, FALSE);
4459   if (stub_entry == NULL)
4460     {
4461       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4462                               section->owner, stub_name);
4463       return NULL;
4464     }
4465
4466   stub_entry->stub_sec = stub_sec;
4467   stub_entry->stub_offset = 0;
4468   stub_entry->id_sec = link_sec;
4469   return stub_entry;
4470 }
4471
4472 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4473    not already done.  */
4474
4475 static bfd_boolean
4476 create_got_section (bfd *abfd, struct bfd_link_info *info)
4477 {
4478   asection *got, *relgot;
4479   flagword flags;
4480   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4481
4482   if (!is_ppc64_elf (abfd))
4483     return FALSE;
4484   if (htab == NULL)
4485     return FALSE;
4486
4487   if (!htab->elf.sgot
4488       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4489     return FALSE;
4490
4491   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4492            | SEC_LINKER_CREATED);
4493
4494   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4495   if (!got
4496       || !bfd_set_section_alignment (abfd, got, 3))
4497     return FALSE;
4498
4499   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4500                                                flags | SEC_READONLY);
4501   if (!relgot
4502       || ! bfd_set_section_alignment (abfd, relgot, 3))
4503     return FALSE;
4504
4505   ppc64_elf_tdata (abfd)->got = got;
4506   ppc64_elf_tdata (abfd)->relgot = relgot;
4507   return TRUE;
4508 }
4509
4510 /* Create the dynamic sections, and set up shortcuts.  */
4511
4512 static bfd_boolean
4513 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4514 {
4515   struct ppc_link_hash_table *htab;
4516
4517   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4518     return FALSE;
4519
4520   htab = ppc_hash_table (info);
4521   if (htab == NULL)
4522     return FALSE;
4523
4524   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4525   if (!info->shared)
4526     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4527
4528   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4529       || (!info->shared && !htab->relbss))
4530     abort ();
4531
4532   return TRUE;
4533 }
4534
4535 /* Follow indirect and warning symbol links.  */
4536
4537 static inline struct bfd_link_hash_entry *
4538 follow_link (struct bfd_link_hash_entry *h)
4539 {
4540   while (h->type == bfd_link_hash_indirect
4541          || h->type == bfd_link_hash_warning)
4542     h = h->u.i.link;
4543   return h;
4544 }
4545
4546 static inline struct elf_link_hash_entry *
4547 elf_follow_link (struct elf_link_hash_entry *h)
4548 {
4549   return (struct elf_link_hash_entry *) follow_link (&h->root);
4550 }
4551
4552 static inline struct ppc_link_hash_entry *
4553 ppc_follow_link (struct ppc_link_hash_entry *h)
4554 {
4555   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4556 }
4557
4558 /* Merge PLT info on FROM with that on TO.  */
4559
4560 static void
4561 move_plt_plist (struct ppc_link_hash_entry *from,
4562                 struct ppc_link_hash_entry *to)
4563 {
4564   if (from->elf.plt.plist != NULL)
4565     {
4566       if (to->elf.plt.plist != NULL)
4567         {
4568           struct plt_entry **entp;
4569           struct plt_entry *ent;
4570
4571           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4572             {
4573               struct plt_entry *dent;
4574
4575               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4576                 if (dent->addend == ent->addend)
4577                   {
4578                     dent->plt.refcount += ent->plt.refcount;
4579                     *entp = ent->next;
4580                     break;
4581                   }
4582               if (dent == NULL)
4583                 entp = &ent->next;
4584             }
4585           *entp = to->elf.plt.plist;
4586         }
4587
4588       to->elf.plt.plist = from->elf.plt.plist;
4589       from->elf.plt.plist = NULL;
4590     }
4591 }
4592
4593 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4594
4595 static void
4596 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4597                                 struct elf_link_hash_entry *dir,
4598                                 struct elf_link_hash_entry *ind)
4599 {
4600   struct ppc_link_hash_entry *edir, *eind;
4601
4602   edir = (struct ppc_link_hash_entry *) dir;
4603   eind = (struct ppc_link_hash_entry *) ind;
4604
4605   edir->is_func |= eind->is_func;
4606   edir->is_func_descriptor |= eind->is_func_descriptor;
4607   edir->tls_mask |= eind->tls_mask;
4608   if (eind->oh != NULL)
4609     edir->oh = ppc_follow_link (eind->oh);
4610
4611   /* If called to transfer flags for a weakdef during processing
4612      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4613      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4614   if (!(ELIMINATE_COPY_RELOCS
4615         && eind->elf.root.type != bfd_link_hash_indirect
4616         && edir->elf.dynamic_adjusted))
4617     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4618
4619   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4620   edir->elf.ref_regular |= eind->elf.ref_regular;
4621   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4622   edir->elf.needs_plt |= eind->elf.needs_plt;
4623   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4624
4625   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4626   if (eind->dyn_relocs != NULL)
4627     {
4628       if (edir->dyn_relocs != NULL)
4629         {
4630           struct elf_dyn_relocs **pp;
4631           struct elf_dyn_relocs *p;
4632
4633           /* Add reloc counts against the indirect sym to the direct sym
4634              list.  Merge any entries against the same section.  */
4635           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4636             {
4637               struct elf_dyn_relocs *q;
4638
4639               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4640                 if (q->sec == p->sec)
4641                   {
4642                     q->pc_count += p->pc_count;
4643                     q->count += p->count;
4644                     *pp = p->next;
4645                     break;
4646                   }
4647               if (q == NULL)
4648                 pp = &p->next;
4649             }
4650           *pp = edir->dyn_relocs;
4651         }
4652
4653       edir->dyn_relocs = eind->dyn_relocs;
4654       eind->dyn_relocs = NULL;
4655     }
4656
4657   /* If we were called to copy over info for a weak sym, that's all.
4658      You might think dyn_relocs need not be copied over;  After all,
4659      both syms will be dynamic or both non-dynamic so we're just
4660      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4661      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4662      dyn_relocs in read-only sections, and it does so on what is the
4663      DIR sym here.  */
4664   if (eind->elf.root.type != bfd_link_hash_indirect)
4665     return;
4666
4667   /* Copy over got entries that we may have already seen to the
4668      symbol which just became indirect.  */
4669   if (eind->elf.got.glist != NULL)
4670     {
4671       if (edir->elf.got.glist != NULL)
4672         {
4673           struct got_entry **entp;
4674           struct got_entry *ent;
4675
4676           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4677             {
4678               struct got_entry *dent;
4679
4680               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4681                 if (dent->addend == ent->addend
4682                     && dent->owner == ent->owner
4683                     && dent->tls_type == ent->tls_type)
4684                   {
4685                     dent->got.refcount += ent->got.refcount;
4686                     *entp = ent->next;
4687                     break;
4688                   }
4689               if (dent == NULL)
4690                 entp = &ent->next;
4691             }
4692           *entp = edir->elf.got.glist;
4693         }
4694
4695       edir->elf.got.glist = eind->elf.got.glist;
4696       eind->elf.got.glist = NULL;
4697     }
4698
4699   /* And plt entries.  */
4700   move_plt_plist (eind, edir);
4701
4702   if (eind->elf.dynindx != -1)
4703     {
4704       if (edir->elf.dynindx != -1)
4705         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4706                                 edir->elf.dynstr_index);
4707       edir->elf.dynindx = eind->elf.dynindx;
4708       edir->elf.dynstr_index = eind->elf.dynstr_index;
4709       eind->elf.dynindx = -1;
4710       eind->elf.dynstr_index = 0;
4711     }
4712 }
4713
4714 /* Find the function descriptor hash entry from the given function code
4715    hash entry FH.  Link the entries via their OH fields.  */
4716
4717 static struct ppc_link_hash_entry *
4718 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4719 {
4720   struct ppc_link_hash_entry *fdh = fh->oh;
4721
4722   if (fdh == NULL)
4723     {
4724       const char *fd_name = fh->elf.root.root.string + 1;
4725
4726       fdh = (struct ppc_link_hash_entry *)
4727         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4728       if (fdh == NULL)
4729         return fdh;
4730
4731       fdh->is_func_descriptor = 1;
4732       fdh->oh = fh;
4733       fh->is_func = 1;
4734       fh->oh = fdh;
4735     }
4736
4737   return ppc_follow_link (fdh);
4738 }
4739
4740 /* Make a fake function descriptor sym for the code sym FH.  */
4741
4742 static struct ppc_link_hash_entry *
4743 make_fdh (struct bfd_link_info *info,
4744           struct ppc_link_hash_entry *fh)
4745 {
4746   bfd *abfd;
4747   asymbol *newsym;
4748   struct bfd_link_hash_entry *bh;
4749   struct ppc_link_hash_entry *fdh;
4750
4751   abfd = fh->elf.root.u.undef.abfd;
4752   newsym = bfd_make_empty_symbol (abfd);
4753   newsym->name = fh->elf.root.root.string + 1;
4754   newsym->section = bfd_und_section_ptr;
4755   newsym->value = 0;
4756   newsym->flags = BSF_WEAK;
4757
4758   bh = NULL;
4759   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4760                                          newsym->flags, newsym->section,
4761                                          newsym->value, NULL, FALSE, FALSE,
4762                                          &bh))
4763     return NULL;
4764
4765   fdh = (struct ppc_link_hash_entry *) bh;
4766   fdh->elf.non_elf = 0;
4767   fdh->fake = 1;
4768   fdh->is_func_descriptor = 1;
4769   fdh->oh = fh;
4770   fh->is_func = 1;
4771   fh->oh = fdh;
4772   return fdh;
4773 }
4774
4775 /* Fix function descriptor symbols defined in .opd sections to be
4776    function type.  */
4777
4778 static bfd_boolean
4779 ppc64_elf_add_symbol_hook (bfd *ibfd,
4780                            struct bfd_link_info *info,
4781                            Elf_Internal_Sym *isym,
4782                            const char **name,
4783                            flagword *flags ATTRIBUTE_UNUSED,
4784                            asection **sec,
4785                            bfd_vma *value ATTRIBUTE_UNUSED)
4786 {
4787   if ((ibfd->flags & DYNAMIC) == 0
4788       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4789     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4790
4791   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4792     {
4793       if ((ibfd->flags & DYNAMIC) == 0)
4794         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4795     }
4796   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4797     ;
4798   else if (*sec != NULL
4799            && strcmp ((*sec)->name, ".opd") == 0)
4800     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4801
4802   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4803     {
4804       if (abiversion (ibfd) == 0)
4805         set_abiversion (ibfd, 2);
4806       else if (abiversion (ibfd) == 1)
4807         {
4808           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4809                                     " for ABI version 1\n"), name);
4810           bfd_set_error (bfd_error_bad_value);
4811           return FALSE;
4812         }
4813     }
4814
4815   return TRUE;
4816 }
4817
4818 /* Merge non-visibility st_other attributes: local entry point.  */
4819
4820 static void
4821 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4822                                   const Elf_Internal_Sym *isym,
4823                                   bfd_boolean definition,
4824                                   bfd_boolean dynamic)
4825 {
4826   if (definition && !dynamic)
4827     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4828                 | ELF_ST_VISIBILITY (h->other));
4829 }
4830
4831 /* This function makes an old ABI object reference to ".bar" cause the
4832    inclusion of a new ABI object archive that defines "bar".
4833    NAME is a symbol defined in an archive.  Return a symbol in the hash
4834    table that might be satisfied by the archive symbols.  */
4835
4836 static struct elf_link_hash_entry *
4837 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4838                                  struct bfd_link_info *info,
4839                                  const char *name)
4840 {
4841   struct elf_link_hash_entry *h;
4842   char *dot_name;
4843   size_t len;
4844
4845   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4846   if (h != NULL
4847       /* Don't return this sym if it is a fake function descriptor
4848          created by add_symbol_adjust.  */
4849       && !(h->root.type == bfd_link_hash_undefweak
4850            && ((struct ppc_link_hash_entry *) h)->fake))
4851     return h;
4852
4853   if (name[0] == '.')
4854     return h;
4855
4856   len = strlen (name);
4857   dot_name = bfd_alloc (abfd, len + 2);
4858   if (dot_name == NULL)
4859     return (struct elf_link_hash_entry *) 0 - 1;
4860   dot_name[0] = '.';
4861   memcpy (dot_name + 1, name, len + 1);
4862   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4863   bfd_release (abfd, dot_name);
4864   return h;
4865 }
4866
4867 /* This function satisfies all old ABI object references to ".bar" if a
4868    new ABI object defines "bar".  Well, at least, undefined dot symbols
4869    are made weak.  This stops later archive searches from including an
4870    object if we already have a function descriptor definition.  It also
4871    prevents the linker complaining about undefined symbols.
4872    We also check and correct mismatched symbol visibility here.  The
4873    most restrictive visibility of the function descriptor and the
4874    function entry symbol is used.  */
4875
4876 static bfd_boolean
4877 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4878 {
4879   struct ppc_link_hash_table *htab;
4880   struct ppc_link_hash_entry *fdh;
4881
4882   if (eh->elf.root.type == bfd_link_hash_indirect)
4883     return TRUE;
4884
4885   if (eh->elf.root.type == bfd_link_hash_warning)
4886     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4887
4888   if (eh->elf.root.root.string[0] != '.')
4889     abort ();
4890
4891   htab = ppc_hash_table (info);
4892   if (htab == NULL)
4893     return FALSE;
4894
4895   fdh = lookup_fdh (eh, htab);
4896   if (fdh == NULL)
4897     {
4898       if (!info->relocatable
4899           && (eh->elf.root.type == bfd_link_hash_undefined
4900               || eh->elf.root.type == bfd_link_hash_undefweak)
4901           && eh->elf.ref_regular)
4902         {
4903           /* Make an undefweak function descriptor sym, which is enough to
4904              pull in an --as-needed shared lib, but won't cause link
4905              errors.  Archives are handled elsewhere.  */
4906           fdh = make_fdh (info, eh);
4907           if (fdh == NULL)
4908             return FALSE;
4909           fdh->elf.ref_regular = 1;
4910         }
4911     }
4912   else
4913     {
4914       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4915       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4916       if (entry_vis < descr_vis)
4917         fdh->elf.other += entry_vis - descr_vis;
4918       else if (entry_vis > descr_vis)
4919         eh->elf.other += descr_vis - entry_vis;
4920
4921       if ((fdh->elf.root.type == bfd_link_hash_defined
4922            || fdh->elf.root.type == bfd_link_hash_defweak)
4923           && eh->elf.root.type == bfd_link_hash_undefined)
4924         {
4925           eh->elf.root.type = bfd_link_hash_undefweak;
4926           eh->was_undefined = 1;
4927           htab->twiddled_syms = 1;
4928         }
4929     }
4930
4931   return TRUE;
4932 }
4933
4934 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_process_dot_syms (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       p = &htab->dot_syms;
4951       while ((eh = *p) != NULL)
4952         {
4953           *p = NULL;
4954           if (&eh->elf == htab->elf.hgot)
4955             ;
4956           else if (htab->elf.hgot == NULL
4957                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4958             htab->elf.hgot = &eh->elf;
4959           else if (!add_symbol_adjust (eh, info))
4960             return FALSE;
4961           p = &eh->u.next_dot_sym;
4962         }
4963     }
4964
4965   /* Clear the list for non-ppc64 input files.  */
4966   p = &htab->dot_syms;
4967   while ((eh = *p) != NULL)
4968     {
4969       *p = NULL;
4970       p = &eh->u.next_dot_sym;
4971     }
4972
4973   /* We need to fix the undefs list for any syms we have twiddled to
4974      undef_weak.  */
4975   if (htab->twiddled_syms)
4976     {
4977       bfd_link_repair_undef_list (&htab->elf.root);
4978       htab->twiddled_syms = 0;
4979     }
4980   return TRUE;
4981 }
4982
4983 /* Undo hash table changes when an --as-needed input file is determined
4984    not to be needed.  */
4985
4986 static bfd_boolean
4987 ppc64_elf_notice_as_needed (bfd *ibfd,
4988                             struct bfd_link_info *info,
4989                             enum notice_asneeded_action act)
4990 {
4991   if (act == notice_not_needed)
4992     {
4993       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4994
4995       if (htab == NULL)
4996         return FALSE;
4997
4998       htab->dot_syms = NULL;
4999     }
5000   return _bfd_elf_notice_as_needed (ibfd, info, act);
5001 }
5002
5003 /* If --just-symbols against a final linked binary, then assume we need
5004    toc adjusting stubs when calling functions defined there.  */
5005
5006 static void
5007 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5008 {
5009   if ((sec->flags & SEC_CODE) != 0
5010       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5011       && is_ppc64_elf (sec->owner))
5012     {
5013       if (abiversion (sec->owner) >= 2
5014           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5015         sec->has_toc_reloc = 1;
5016     }
5017   _bfd_elf_link_just_syms (sec, info);
5018 }
5019
5020 static struct plt_entry **
5021 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5022                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5023 {
5024   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5025   struct plt_entry **local_plt;
5026   unsigned char *local_got_tls_masks;
5027
5028   if (local_got_ents == NULL)
5029     {
5030       bfd_size_type size = symtab_hdr->sh_info;
5031
5032       size *= (sizeof (*local_got_ents)
5033                + sizeof (*local_plt)
5034                + sizeof (*local_got_tls_masks));
5035       local_got_ents = bfd_zalloc (abfd, size);
5036       if (local_got_ents == NULL)
5037         return NULL;
5038       elf_local_got_ents (abfd) = local_got_ents;
5039     }
5040
5041   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5042     {
5043       struct got_entry *ent;
5044
5045       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5046         if (ent->addend == r_addend
5047             && ent->owner == abfd
5048             && ent->tls_type == tls_type)
5049           break;
5050       if (ent == NULL)
5051         {
5052           bfd_size_type amt = sizeof (*ent);
5053           ent = bfd_alloc (abfd, amt);
5054           if (ent == NULL)
5055             return FALSE;
5056           ent->next = local_got_ents[r_symndx];
5057           ent->addend = r_addend;
5058           ent->owner = abfd;
5059           ent->tls_type = tls_type;
5060           ent->is_indirect = FALSE;
5061           ent->got.refcount = 0;
5062           local_got_ents[r_symndx] = ent;
5063         }
5064       ent->got.refcount += 1;
5065     }
5066
5067   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5068   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5069   local_got_tls_masks[r_symndx] |= tls_type;
5070
5071   return local_plt + r_symndx;
5072 }
5073
5074 static bfd_boolean
5075 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5076 {
5077   struct plt_entry *ent;
5078
5079   for (ent = *plist; ent != NULL; ent = ent->next)
5080     if (ent->addend == addend)
5081       break;
5082   if (ent == NULL)
5083     {
5084       bfd_size_type amt = sizeof (*ent);
5085       ent = bfd_alloc (abfd, amt);
5086       if (ent == NULL)
5087         return FALSE;
5088       ent->next = *plist;
5089       ent->addend = addend;
5090       ent->plt.refcount = 0;
5091       *plist = ent;
5092     }
5093   ent->plt.refcount += 1;
5094   return TRUE;
5095 }
5096
5097 static bfd_boolean
5098 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5099 {
5100   return (r_type == R_PPC64_REL24
5101           || r_type == R_PPC64_REL14
5102           || r_type == R_PPC64_REL14_BRTAKEN
5103           || r_type == R_PPC64_REL14_BRNTAKEN
5104           || r_type == R_PPC64_ADDR24
5105           || r_type == R_PPC64_ADDR14
5106           || r_type == R_PPC64_ADDR14_BRTAKEN
5107           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5108 }
5109
5110 /* Look through the relocs for a section during the first phase, and
5111    calculate needed space in the global offset table, procedure
5112    linkage table, and dynamic reloc sections.  */
5113
5114 static bfd_boolean
5115 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5116                         asection *sec, const Elf_Internal_Rela *relocs)
5117 {
5118   struct ppc_link_hash_table *htab;
5119   Elf_Internal_Shdr *symtab_hdr;
5120   struct elf_link_hash_entry **sym_hashes;
5121   const Elf_Internal_Rela *rel;
5122   const Elf_Internal_Rela *rel_end;
5123   asection *sreloc;
5124   asection **opd_sym_map;
5125   struct elf_link_hash_entry *tga, *dottga;
5126
5127   if (info->relocatable)
5128     return TRUE;
5129
5130   /* Don't do anything special with non-loaded, non-alloced sections.
5131      In particular, any relocs in such sections should not affect GOT
5132      and PLT reference counting (ie. we don't allow them to create GOT
5133      or PLT entries), there's no possibility or desire to optimize TLS
5134      relocs, and there's not much point in propagating relocs to shared
5135      libs that the dynamic linker won't relocate.  */
5136   if ((sec->flags & SEC_ALLOC) == 0)
5137     return TRUE;
5138
5139   BFD_ASSERT (is_ppc64_elf (abfd));
5140
5141   htab = ppc_hash_table (info);
5142   if (htab == NULL)
5143     return FALSE;
5144
5145   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5146                               FALSE, FALSE, TRUE);
5147   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5148                                  FALSE, FALSE, TRUE);
5149   symtab_hdr = &elf_symtab_hdr (abfd);
5150   sym_hashes = elf_sym_hashes (abfd);
5151   sreloc = NULL;
5152   opd_sym_map = NULL;
5153   if (strcmp (sec->name, ".opd") == 0)
5154     {
5155       /* Garbage collection needs some extra help with .opd sections.
5156          We don't want to necessarily keep everything referenced by
5157          relocs in .opd, as that would keep all functions.  Instead,
5158          if we reference an .opd symbol (a function descriptor), we
5159          want to keep the function code symbol's section.  This is
5160          easy for global symbols, but for local syms we need to keep
5161          information about the associated function section.  */
5162       bfd_size_type amt;
5163
5164       if (abiversion (abfd) == 0)
5165         set_abiversion (abfd, 1);
5166       else if (abiversion (abfd) == 2)
5167         {
5168           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5169                                   abiversion (abfd));
5170           bfd_set_error (bfd_error_bad_value);
5171           return FALSE;
5172         }
5173       amt = sec->size * sizeof (*opd_sym_map) / 8;
5174       opd_sym_map = bfd_zalloc (abfd, amt);
5175       if (opd_sym_map == NULL)
5176         return FALSE;
5177       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5178       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5179       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5180     }
5181
5182   rel_end = relocs + sec->reloc_count;
5183   for (rel = relocs; rel < rel_end; rel++)
5184     {
5185       unsigned long r_symndx;
5186       struct elf_link_hash_entry *h;
5187       enum elf_ppc64_reloc_type r_type;
5188       int tls_type;
5189       struct _ppc64_elf_section_data *ppc64_sec;
5190       struct plt_entry **ifunc;
5191
5192       r_symndx = ELF64_R_SYM (rel->r_info);
5193       if (r_symndx < symtab_hdr->sh_info)
5194         h = NULL;
5195       else
5196         {
5197           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5198           h = elf_follow_link (h);
5199
5200           /* PR15323, ref flags aren't set for references in the same
5201              object.  */
5202           h->root.non_ir_ref = 1;
5203
5204           if (h == htab->elf.hgot)
5205             sec->has_toc_reloc = 1;
5206         }
5207
5208       tls_type = 0;
5209       ifunc = NULL;
5210       if (h != NULL)
5211         {
5212           if (h->type == STT_GNU_IFUNC)
5213             {
5214               h->needs_plt = 1;
5215               ifunc = &h->plt.plist;
5216             }
5217         }
5218       else
5219         {
5220           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5221                                                           abfd, r_symndx);
5222           if (isym == NULL)
5223             return FALSE;
5224
5225           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5226             {
5227               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5228                                              rel->r_addend, PLT_IFUNC);
5229               if (ifunc == NULL)
5230                 return FALSE;
5231             }
5232         }
5233       r_type = ELF64_R_TYPE (rel->r_info);
5234       if (is_branch_reloc (r_type))
5235         {
5236           if (h != NULL && (h == tga || h == dottga))
5237             {
5238               if (rel != relocs
5239                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5240                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5241                 /* We have a new-style __tls_get_addr call with a marker
5242                    reloc.  */
5243                 ;
5244               else
5245                 /* Mark this section as having an old-style call.  */
5246                 sec->has_tls_get_addr_call = 1;
5247             }
5248
5249           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5250           if (ifunc != NULL
5251               && !update_plt_info (abfd, ifunc, rel->r_addend))
5252             return FALSE;
5253         }
5254
5255       switch (r_type)
5256         {
5257         case R_PPC64_TLSGD:
5258         case R_PPC64_TLSLD:
5259           /* These special tls relocs tie a call to __tls_get_addr with
5260              its parameter symbol.  */
5261           break;
5262
5263         case R_PPC64_GOT_TLSLD16:
5264         case R_PPC64_GOT_TLSLD16_LO:
5265         case R_PPC64_GOT_TLSLD16_HI:
5266         case R_PPC64_GOT_TLSLD16_HA:
5267           tls_type = TLS_TLS | TLS_LD;
5268           goto dogottls;
5269
5270         case R_PPC64_GOT_TLSGD16:
5271         case R_PPC64_GOT_TLSGD16_LO:
5272         case R_PPC64_GOT_TLSGD16_HI:
5273         case R_PPC64_GOT_TLSGD16_HA:
5274           tls_type = TLS_TLS | TLS_GD;
5275           goto dogottls;
5276
5277         case R_PPC64_GOT_TPREL16_DS:
5278         case R_PPC64_GOT_TPREL16_LO_DS:
5279         case R_PPC64_GOT_TPREL16_HI:
5280         case R_PPC64_GOT_TPREL16_HA:
5281           if (!info->executable)
5282             info->flags |= DF_STATIC_TLS;
5283           tls_type = TLS_TLS | TLS_TPREL;
5284           goto dogottls;
5285
5286         case R_PPC64_GOT_DTPREL16_DS:
5287         case R_PPC64_GOT_DTPREL16_LO_DS:
5288         case R_PPC64_GOT_DTPREL16_HI:
5289         case R_PPC64_GOT_DTPREL16_HA:
5290           tls_type = TLS_TLS | TLS_DTPREL;
5291         dogottls:
5292           sec->has_tls_reloc = 1;
5293           /* Fall thru */
5294
5295         case R_PPC64_GOT16:
5296         case R_PPC64_GOT16_DS:
5297         case R_PPC64_GOT16_HA:
5298         case R_PPC64_GOT16_HI:
5299         case R_PPC64_GOT16_LO:
5300         case R_PPC64_GOT16_LO_DS:
5301           /* This symbol requires a global offset table entry.  */
5302           sec->has_toc_reloc = 1;
5303           if (r_type == R_PPC64_GOT_TLSLD16
5304               || r_type == R_PPC64_GOT_TLSGD16
5305               || r_type == R_PPC64_GOT_TPREL16_DS
5306               || r_type == R_PPC64_GOT_DTPREL16_DS
5307               || r_type == R_PPC64_GOT16
5308               || r_type == R_PPC64_GOT16_DS)
5309             {
5310               htab->do_multi_toc = 1;
5311               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5312             }
5313
5314           if (ppc64_elf_tdata (abfd)->got == NULL
5315               && !create_got_section (abfd, info))
5316             return FALSE;
5317
5318           if (h != NULL)
5319             {
5320               struct ppc_link_hash_entry *eh;
5321               struct got_entry *ent;
5322
5323               eh = (struct ppc_link_hash_entry *) h;
5324               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5325                 if (ent->addend == rel->r_addend
5326                     && ent->owner == abfd
5327                     && ent->tls_type == tls_type)
5328                   break;
5329               if (ent == NULL)
5330                 {
5331                   bfd_size_type amt = sizeof (*ent);
5332                   ent = bfd_alloc (abfd, amt);
5333                   if (ent == NULL)
5334                     return FALSE;
5335                   ent->next = eh->elf.got.glist;
5336                   ent->addend = rel->r_addend;
5337                   ent->owner = abfd;
5338                   ent->tls_type = tls_type;
5339                   ent->is_indirect = FALSE;
5340                   ent->got.refcount = 0;
5341                   eh->elf.got.glist = ent;
5342                 }
5343               ent->got.refcount += 1;
5344               eh->tls_mask |= tls_type;
5345             }
5346           else
5347             /* This is a global offset table entry for a local symbol.  */
5348             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5349                                         rel->r_addend, tls_type))
5350               return FALSE;
5351
5352           /* We may also need a plt entry if the symbol turns out to be
5353              an ifunc.  */
5354           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5355             {
5356               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5357                 return FALSE;
5358             }
5359           break;
5360
5361         case R_PPC64_PLT16_HA:
5362         case R_PPC64_PLT16_HI:
5363         case R_PPC64_PLT16_LO:
5364         case R_PPC64_PLT32:
5365         case R_PPC64_PLT64:
5366           /* This symbol requires a procedure linkage table entry.  We
5367              actually build the entry in adjust_dynamic_symbol,
5368              because this might be a case of linking PIC code without
5369              linking in any dynamic objects, in which case we don't
5370              need to generate a procedure linkage table after all.  */
5371           if (h == NULL)
5372             {
5373               /* It does not make sense to have a procedure linkage
5374                  table entry for a local symbol.  */
5375               bfd_set_error (bfd_error_bad_value);
5376               return FALSE;
5377             }
5378           else
5379             {
5380               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5381                 return FALSE;
5382               h->needs_plt = 1;
5383               if (h->root.root.string[0] == '.'
5384                   && h->root.root.string[1] != '\0')
5385                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5386             }
5387           break;
5388
5389           /* The following relocations don't need to propagate the
5390              relocation if linking a shared object since they are
5391              section relative.  */
5392         case R_PPC64_SECTOFF:
5393         case R_PPC64_SECTOFF_LO:
5394         case R_PPC64_SECTOFF_HI:
5395         case R_PPC64_SECTOFF_HA:
5396         case R_PPC64_SECTOFF_DS:
5397         case R_PPC64_SECTOFF_LO_DS:
5398         case R_PPC64_DTPREL16:
5399         case R_PPC64_DTPREL16_LO:
5400         case R_PPC64_DTPREL16_HI:
5401         case R_PPC64_DTPREL16_HA:
5402         case R_PPC64_DTPREL16_DS:
5403         case R_PPC64_DTPREL16_LO_DS:
5404         case R_PPC64_DTPREL16_HIGH:
5405         case R_PPC64_DTPREL16_HIGHA:
5406         case R_PPC64_DTPREL16_HIGHER:
5407         case R_PPC64_DTPREL16_HIGHERA:
5408         case R_PPC64_DTPREL16_HIGHEST:
5409         case R_PPC64_DTPREL16_HIGHESTA:
5410           break;
5411
5412           /* Nor do these.  */
5413         case R_PPC64_REL16:
5414         case R_PPC64_REL16_LO:
5415         case R_PPC64_REL16_HI:
5416         case R_PPC64_REL16_HA:
5417           break;
5418
5419           /* Not supported as a dynamic relocation.  */
5420         case R_PPC64_ADDR64_LOCAL:
5421           if (info->shared)
5422             {
5423               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5424                 ppc_howto_init ();
5425               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5426                                         "in shared libraries and PIEs.\n"),
5427                                       abfd, sec, rel->r_offset,
5428                                       ppc64_elf_howto_table[r_type]->name);
5429               bfd_set_error (bfd_error_bad_value);
5430               return FALSE;
5431             }
5432           break;
5433
5434         case R_PPC64_TOC16:
5435         case R_PPC64_TOC16_DS:
5436           htab->do_multi_toc = 1;
5437           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5438         case R_PPC64_TOC16_LO:
5439         case R_PPC64_TOC16_HI:
5440         case R_PPC64_TOC16_HA:
5441         case R_PPC64_TOC16_LO_DS:
5442           sec->has_toc_reloc = 1;
5443           break;
5444
5445           /* This relocation describes the C++ object vtable hierarchy.
5446              Reconstruct it for later use during GC.  */
5447         case R_PPC64_GNU_VTINHERIT:
5448           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5449             return FALSE;
5450           break;
5451
5452           /* This relocation describes which C++ vtable entries are actually
5453              used.  Record for later use during GC.  */
5454         case R_PPC64_GNU_VTENTRY:
5455           BFD_ASSERT (h != NULL);
5456           if (h != NULL
5457               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5458             return FALSE;
5459           break;
5460
5461         case R_PPC64_REL14:
5462         case R_PPC64_REL14_BRTAKEN:
5463         case R_PPC64_REL14_BRNTAKEN:
5464           {
5465             asection *dest = NULL;
5466
5467             /* Heuristic: If jumping outside our section, chances are
5468                we are going to need a stub.  */
5469             if (h != NULL)
5470               {
5471                 /* If the sym is weak it may be overridden later, so
5472                    don't assume we know where a weak sym lives.  */
5473                 if (h->root.type == bfd_link_hash_defined)
5474                   dest = h->root.u.def.section;
5475               }
5476             else
5477               {
5478                 Elf_Internal_Sym *isym;
5479
5480                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5481                                               abfd, r_symndx);
5482                 if (isym == NULL)
5483                   return FALSE;
5484
5485                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5486               }
5487
5488             if (dest != sec)
5489               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5490           }
5491           /* Fall through.  */
5492
5493         case R_PPC64_REL24:
5494           if (h != NULL && ifunc == NULL)
5495             {
5496               /* We may need a .plt entry if the function this reloc
5497                  refers to is in a shared lib.  */
5498               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5499                 return FALSE;
5500               h->needs_plt = 1;
5501               if (h->root.root.string[0] == '.'
5502                   && h->root.root.string[1] != '\0')
5503                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5504               if (h == tga || h == dottga)
5505                 sec->has_tls_reloc = 1;
5506             }
5507           break;
5508
5509         case R_PPC64_TPREL64:
5510           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5511           if (!info->executable)
5512             info->flags |= DF_STATIC_TLS;
5513           goto dotlstoc;
5514
5515         case R_PPC64_DTPMOD64:
5516           if (rel + 1 < rel_end
5517               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5518               && rel[1].r_offset == rel->r_offset + 8)
5519             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5520           else
5521             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5522           goto dotlstoc;
5523
5524         case R_PPC64_DTPREL64:
5525           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5526           if (rel != relocs
5527               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5528               && rel[-1].r_offset == rel->r_offset - 8)
5529             /* This is the second reloc of a dtpmod, dtprel pair.
5530                Don't mark with TLS_DTPREL.  */
5531             goto dodyn;
5532
5533         dotlstoc:
5534           sec->has_tls_reloc = 1;
5535           if (h != NULL)
5536             {
5537               struct ppc_link_hash_entry *eh;
5538               eh = (struct ppc_link_hash_entry *) h;
5539               eh->tls_mask |= tls_type;
5540             }
5541           else
5542             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5543                                         rel->r_addend, tls_type))
5544               return FALSE;
5545
5546           ppc64_sec = ppc64_elf_section_data (sec);
5547           if (ppc64_sec->sec_type != sec_toc)
5548             {
5549               bfd_size_type amt;
5550
5551               /* One extra to simplify get_tls_mask.  */
5552               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5553               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5554               if (ppc64_sec->u.toc.symndx == NULL)
5555                 return FALSE;
5556               amt = sec->size * sizeof (bfd_vma) / 8;
5557               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5558               if (ppc64_sec->u.toc.add == NULL)
5559                 return FALSE;
5560               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5561               ppc64_sec->sec_type = sec_toc;
5562             }
5563           BFD_ASSERT (rel->r_offset % 8 == 0);
5564           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5565           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5566
5567           /* Mark the second slot of a GD or LD entry.
5568              -1 to indicate GD and -2 to indicate LD.  */
5569           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5570             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5571           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5572             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5573           goto dodyn;
5574
5575         case R_PPC64_TPREL16:
5576         case R_PPC64_TPREL16_LO:
5577         case R_PPC64_TPREL16_HI:
5578         case R_PPC64_TPREL16_HA:
5579         case R_PPC64_TPREL16_DS:
5580         case R_PPC64_TPREL16_LO_DS:
5581         case R_PPC64_TPREL16_HIGH:
5582         case R_PPC64_TPREL16_HIGHA:
5583         case R_PPC64_TPREL16_HIGHER:
5584         case R_PPC64_TPREL16_HIGHERA:
5585         case R_PPC64_TPREL16_HIGHEST:
5586         case R_PPC64_TPREL16_HIGHESTA:
5587           if (info->shared)
5588             {
5589               if (!info->executable)
5590                 info->flags |= DF_STATIC_TLS;
5591               goto dodyn;
5592             }
5593           break;
5594
5595         case R_PPC64_ADDR64:
5596           if (opd_sym_map != NULL
5597               && rel + 1 < rel_end
5598               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5599             {
5600               if (h != NULL)
5601                 {
5602                   if (h->root.root.string[0] == '.'
5603                       && h->root.root.string[1] != 0
5604                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5605                     ;
5606                   else
5607                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5608                 }
5609               else
5610                 {
5611                   asection *s;
5612                   Elf_Internal_Sym *isym;
5613
5614                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5615                                                 abfd, r_symndx);
5616                   if (isym == NULL)
5617                     return FALSE;
5618
5619                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5620                   if (s != NULL && s != sec)
5621                     opd_sym_map[rel->r_offset / 8] = s;
5622                 }
5623             }
5624           /* Fall through.  */
5625
5626         case R_PPC64_ADDR16:
5627         case R_PPC64_ADDR16_DS:
5628         case R_PPC64_ADDR16_HA:
5629         case R_PPC64_ADDR16_HI:
5630         case R_PPC64_ADDR16_HIGH:
5631         case R_PPC64_ADDR16_HIGHA:
5632         case R_PPC64_ADDR16_HIGHER:
5633         case R_PPC64_ADDR16_HIGHERA:
5634         case R_PPC64_ADDR16_HIGHEST:
5635         case R_PPC64_ADDR16_HIGHESTA:
5636         case R_PPC64_ADDR16_LO:
5637         case R_PPC64_ADDR16_LO_DS:
5638           if (h != NULL && !info->shared && abiversion (abfd) == 2
5639               && rel->r_addend == 0)
5640             {
5641               /* We may need a .plt entry if this reloc refers to a
5642                  function in a shared lib.  */
5643               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5644                 return FALSE;
5645               h->pointer_equality_needed = 1;
5646             }
5647           /* Fall through.  */
5648
5649         case R_PPC64_REL30:
5650         case R_PPC64_REL32:
5651         case R_PPC64_REL64:
5652         case R_PPC64_ADDR14:
5653         case R_PPC64_ADDR14_BRNTAKEN:
5654         case R_PPC64_ADDR14_BRTAKEN:
5655         case R_PPC64_ADDR24:
5656         case R_PPC64_ADDR32:
5657         case R_PPC64_UADDR16:
5658         case R_PPC64_UADDR32:
5659         case R_PPC64_UADDR64:
5660         case R_PPC64_TOC:
5661           if (h != NULL && !info->shared)
5662             /* We may need a copy reloc.  */
5663             h->non_got_ref = 1;
5664
5665           /* Don't propagate .opd relocs.  */
5666           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5667             break;
5668
5669           /* If we are creating a shared library, and this is a reloc
5670              against a global symbol, or a non PC relative reloc
5671              against a local symbol, then we need to copy the reloc
5672              into the shared library.  However, if we are linking with
5673              -Bsymbolic, we do not need to copy a reloc against a
5674              global symbol which is defined in an object we are
5675              including in the link (i.e., DEF_REGULAR is set).  At
5676              this point we have not seen all the input files, so it is
5677              possible that DEF_REGULAR is not set now but will be set
5678              later (it is never cleared).  In case of a weak definition,
5679              DEF_REGULAR may be cleared later by a strong definition in
5680              a shared library.  We account for that possibility below by
5681              storing information in the dyn_relocs field of the hash
5682              table entry.  A similar situation occurs when creating
5683              shared libraries and symbol visibility changes render the
5684              symbol local.
5685
5686              If on the other hand, we are creating an executable, we
5687              may need to keep relocations for symbols satisfied by a
5688              dynamic library if we manage to avoid copy relocs for the
5689              symbol.  */
5690         dodyn:
5691           if ((info->shared
5692                && (must_be_dyn_reloc (info, r_type)
5693                    || (h != NULL
5694                        && (!SYMBOLIC_BIND (info, h)
5695                            || h->root.type == bfd_link_hash_defweak
5696                            || !h->def_regular))))
5697               || (ELIMINATE_COPY_RELOCS
5698                   && !info->shared
5699                   && h != NULL
5700                   && (h->root.type == bfd_link_hash_defweak
5701                       || !h->def_regular))
5702               || (!info->shared
5703                   && ifunc != NULL))
5704             {
5705               /* We must copy these reloc types into the output file.
5706                  Create a reloc section in dynobj and make room for
5707                  this reloc.  */
5708               if (sreloc == NULL)
5709                 {
5710                   sreloc = _bfd_elf_make_dynamic_reloc_section
5711                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5712
5713                   if (sreloc == NULL)
5714                     return FALSE;
5715                 }
5716
5717               /* If this is a global symbol, we count the number of
5718                  relocations we need for this symbol.  */
5719               if (h != NULL)
5720                 {
5721                   struct elf_dyn_relocs *p;
5722                   struct elf_dyn_relocs **head;
5723
5724                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5725                   p = *head;
5726                   if (p == NULL || p->sec != sec)
5727                     {
5728                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5729                       if (p == NULL)
5730                         return FALSE;
5731                       p->next = *head;
5732                       *head = p;
5733                       p->sec = sec;
5734                       p->count = 0;
5735                       p->pc_count = 0;
5736                     }
5737                   p->count += 1;
5738                   if (!must_be_dyn_reloc (info, r_type))
5739                     p->pc_count += 1;
5740                 }
5741               else
5742                 {
5743                   /* Track dynamic relocs needed for local syms too.
5744                      We really need local syms available to do this
5745                      easily.  Oh well.  */
5746                   struct ppc_dyn_relocs *p;
5747                   struct ppc_dyn_relocs **head;
5748                   bfd_boolean is_ifunc;
5749                   asection *s;
5750                   void *vpp;
5751                   Elf_Internal_Sym *isym;
5752
5753                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5754                                                 abfd, r_symndx);
5755                   if (isym == NULL)
5756                     return FALSE;
5757
5758                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5759                   if (s == NULL)
5760                     s = sec;
5761
5762                   vpp = &elf_section_data (s)->local_dynrel;
5763                   head = (struct ppc_dyn_relocs **) vpp;
5764                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5765                   p = *head;
5766                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5767                     p = p->next;
5768                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5769                     {
5770                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5771                       if (p == NULL)
5772                         return FALSE;
5773                       p->next = *head;
5774                       *head = p;
5775                       p->sec = sec;
5776                       p->ifunc = is_ifunc;
5777                       p->count = 0;
5778                     }
5779                   p->count += 1;
5780                 }
5781             }
5782           break;
5783
5784         default:
5785           break;
5786         }
5787     }
5788
5789   return TRUE;
5790 }
5791
5792 /* Merge backend specific data from an object file to the output
5793    object file when linking.  */
5794
5795 static bfd_boolean
5796 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5797 {
5798   unsigned long iflags, oflags;
5799
5800   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5801     return TRUE;
5802
5803   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5804     return TRUE;
5805
5806   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5807     return FALSE;
5808
5809   iflags = elf_elfheader (ibfd)->e_flags;
5810   oflags = elf_elfheader (obfd)->e_flags;
5811
5812   if (!elf_flags_init (obfd) || oflags == 0)
5813     {
5814       elf_flags_init (obfd) = TRUE;
5815       elf_elfheader (obfd)->e_flags = iflags;
5816     }
5817   else if (iflags == oflags || iflags == 0)
5818     ;
5819   else if (iflags & ~EF_PPC64_ABI)
5820     {
5821       (*_bfd_error_handler)
5822         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5823       bfd_set_error (bfd_error_bad_value);
5824       return FALSE;
5825     }
5826   else
5827     {
5828       (*_bfd_error_handler)
5829         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5830          ibfd, iflags, oflags);
5831       bfd_set_error (bfd_error_bad_value);
5832       return FALSE;
5833     }
5834
5835   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5836   _bfd_elf_merge_object_attributes (ibfd, obfd);
5837
5838   return TRUE;
5839 }
5840
5841 static bfd_boolean
5842 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5843 {
5844   /* Print normal ELF private data.  */
5845   _bfd_elf_print_private_bfd_data (abfd, ptr);
5846
5847   if (elf_elfheader (abfd)->e_flags != 0)
5848     {
5849       FILE *file = ptr;
5850
5851       /* xgettext:c-format */
5852       fprintf (file, _("private flags = 0x%lx:"),
5853                elf_elfheader (abfd)->e_flags);
5854
5855       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5856         fprintf (file, _(" [abiv%ld]"),
5857                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5858       fputc ('\n', file);
5859     }
5860
5861   return TRUE;
5862 }
5863
5864 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5865    of the code entry point, and its section.  */
5866
5867 static bfd_vma
5868 opd_entry_value (asection *opd_sec,
5869                  bfd_vma offset,
5870                  asection **code_sec,
5871                  bfd_vma *code_off,
5872                  bfd_boolean in_code_sec)
5873 {
5874   bfd *opd_bfd = opd_sec->owner;
5875   Elf_Internal_Rela *relocs;
5876   Elf_Internal_Rela *lo, *hi, *look;
5877   bfd_vma val;
5878
5879   /* No relocs implies we are linking a --just-symbols object, or looking
5880      at a final linked executable with addr2line or somesuch.  */
5881   if (opd_sec->reloc_count == 0)
5882     {
5883       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5884
5885       if (contents == NULL)
5886         {
5887           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5888             return (bfd_vma) -1;
5889           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5890         }
5891
5892       val = bfd_get_64 (opd_bfd, contents + offset);
5893       if (code_sec != NULL)
5894         {
5895           asection *sec, *likely = NULL;
5896
5897           if (in_code_sec)
5898             {
5899               sec = *code_sec;
5900               if (sec->vma <= val
5901                   && val < sec->vma + sec->size)
5902                 likely = sec;
5903               else
5904                 val = -1;
5905             }
5906           else
5907             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5908               if (sec->vma <= val
5909                   && (sec->flags & SEC_LOAD) != 0
5910                   && (sec->flags & SEC_ALLOC) != 0)
5911                 likely = sec;
5912           if (likely != NULL)
5913             {
5914               *code_sec = likely;
5915               if (code_off != NULL)
5916                 *code_off = val - likely->vma;
5917             }
5918         }
5919       return val;
5920     }
5921
5922   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5923
5924   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5925   if (relocs == NULL)
5926     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5927
5928   /* Go find the opd reloc at the sym address.  */
5929   lo = relocs;
5930   BFD_ASSERT (lo != NULL);
5931   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5932   val = (bfd_vma) -1;
5933   while (lo < hi)
5934     {
5935       look = lo + (hi - lo) / 2;
5936       if (look->r_offset < offset)
5937         lo = look + 1;
5938       else if (look->r_offset > offset)
5939         hi = look;
5940       else
5941         {
5942           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5943
5944           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5945               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5946             {
5947               unsigned long symndx = ELF64_R_SYM (look->r_info);
5948               asection *sec;
5949
5950               if (symndx < symtab_hdr->sh_info
5951                   || elf_sym_hashes (opd_bfd) == NULL)
5952                 {
5953                   Elf_Internal_Sym *sym;
5954
5955                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5956                   if (sym == NULL)
5957                     {
5958                       size_t symcnt = symtab_hdr->sh_info;
5959                       if (elf_sym_hashes (opd_bfd) == NULL)
5960                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5961                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5962                                                   0, NULL, NULL, NULL);
5963                       if (sym == NULL)
5964                         break;
5965                       symtab_hdr->contents = (bfd_byte *) sym;
5966                     }
5967
5968                   sym += symndx;
5969                   val = sym->st_value;
5970                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5971                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5972                 }
5973               else
5974                 {
5975                   struct elf_link_hash_entry **sym_hashes;
5976                   struct elf_link_hash_entry *rh;
5977
5978                   sym_hashes = elf_sym_hashes (opd_bfd);
5979                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5980                   if (rh != NULL)
5981                     {
5982                       rh = elf_follow_link (rh);
5983                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5984                                   || rh->root.type == bfd_link_hash_defweak);
5985                       val = rh->root.u.def.value;
5986                       sec = rh->root.u.def.section;
5987                     }
5988                   else
5989                     {
5990                       /* Handle the odd case where we can be called
5991                          during bfd_elf_link_add_symbols before the
5992                          symbol hashes have been fully populated.  */
5993                       Elf_Internal_Sym *sym;
5994
5995                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5996                                                   symndx, NULL, NULL, NULL);
5997                       if (sym == NULL)
5998                         break;
5999
6000                       val = sym->st_value;
6001                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6002                       free (sym);
6003                     }
6004                 }
6005               val += look->r_addend;
6006               if (code_off != NULL)
6007                 *code_off = val;
6008               if (code_sec != NULL)
6009                 {
6010                   if (in_code_sec && *code_sec != sec)
6011                     return -1;
6012                   else
6013                     *code_sec = sec;
6014                 }
6015               if (sec != NULL && sec->output_section != NULL)
6016                 val += sec->output_section->vma + sec->output_offset;
6017             }
6018           break;
6019         }
6020     }
6021
6022   return val;
6023 }
6024
6025 /* If the ELF symbol SYM might be a function in SEC, return the
6026    function size and set *CODE_OFF to the function's entry point,
6027    otherwise return zero.  */
6028
6029 static bfd_size_type
6030 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6031                               bfd_vma *code_off)
6032 {
6033   bfd_size_type size;
6034
6035   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6036                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6037     return 0;
6038
6039   size = 0;
6040   if (!(sym->flags & BSF_SYNTHETIC))
6041     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6042
6043   if (strcmp (sym->section->name, ".opd") == 0)
6044     {
6045       if (opd_entry_value (sym->section, sym->value,
6046                            &sec, code_off, TRUE) == (bfd_vma) -1)
6047         return 0;
6048       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6049          symbol.  This size has nothing to do with the code size of the
6050          function, which is what we're supposed to return, but the
6051          code size isn't available without looking up the dot-sym.
6052          However, doing that would be a waste of time particularly
6053          since elf_find_function will look at the dot-sym anyway.
6054          Now, elf_find_function will keep the largest size of any
6055          function sym found at the code address of interest, so return
6056          1 here to avoid it incorrectly caching a larger function size
6057          for a small function.  This does mean we return the wrong
6058          size for a new-ABI function of size 24, but all that does is
6059          disable caching for such functions.  */
6060       if (size == 24)
6061         size = 1;
6062     }
6063   else
6064     {
6065       if (sym->section != sec)
6066         return 0;
6067       *code_off = sym->value;
6068     }
6069   if (size == 0)
6070     size = 1;
6071   return size;
6072 }
6073
6074 /* Return true if symbol is defined in a regular object file.  */
6075
6076 static bfd_boolean
6077 is_static_defined (struct elf_link_hash_entry *h)
6078 {
6079   return ((h->root.type == bfd_link_hash_defined
6080            || h->root.type == bfd_link_hash_defweak)
6081           && h->root.u.def.section != NULL
6082           && h->root.u.def.section->output_section != NULL);
6083 }
6084
6085 /* If FDH is a function descriptor symbol, return the associated code
6086    entry symbol if it is defined.  Return NULL otherwise.  */
6087
6088 static struct ppc_link_hash_entry *
6089 defined_code_entry (struct ppc_link_hash_entry *fdh)
6090 {
6091   if (fdh->is_func_descriptor)
6092     {
6093       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6094       if (fh->elf.root.type == bfd_link_hash_defined
6095           || fh->elf.root.type == bfd_link_hash_defweak)
6096         return fh;
6097     }
6098   return NULL;
6099 }
6100
6101 /* If FH is a function code entry symbol, return the associated
6102    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6103
6104 static struct ppc_link_hash_entry *
6105 defined_func_desc (struct ppc_link_hash_entry *fh)
6106 {
6107   if (fh->oh != NULL
6108       && fh->oh->is_func_descriptor)
6109     {
6110       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6111       if (fdh->elf.root.type == bfd_link_hash_defined
6112           || fdh->elf.root.type == bfd_link_hash_defweak)
6113         return fdh;
6114     }
6115   return NULL;
6116 }
6117
6118 /* Mark all our entry sym sections, both opd and code section.  */
6119
6120 static void
6121 ppc64_elf_gc_keep (struct bfd_link_info *info)
6122 {
6123   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6124   struct bfd_sym_chain *sym;
6125
6126   if (htab == NULL)
6127     return;
6128
6129   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6130     {
6131       struct ppc_link_hash_entry *eh, *fh;
6132       asection *sec;
6133
6134       eh = (struct ppc_link_hash_entry *)
6135         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6136       if (eh == NULL)
6137         continue;
6138       if (eh->elf.root.type != bfd_link_hash_defined
6139           && eh->elf.root.type != bfd_link_hash_defweak)
6140         continue;
6141
6142       fh = defined_code_entry (eh);
6143       if (fh != NULL)
6144         {
6145           sec = fh->elf.root.u.def.section;
6146           sec->flags |= SEC_KEEP;
6147         }
6148       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6149                && opd_entry_value (eh->elf.root.u.def.section,
6150                                    eh->elf.root.u.def.value,
6151                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6152         sec->flags |= SEC_KEEP;
6153
6154       sec = eh->elf.root.u.def.section;
6155       sec->flags |= SEC_KEEP;
6156     }
6157 }
6158
6159 /* Mark sections containing dynamically referenced symbols.  When
6160    building shared libraries, we must assume that any visible symbol is
6161    referenced.  */
6162
6163 static bfd_boolean
6164 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6165 {
6166   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6167   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6168   struct ppc_link_hash_entry *fdh;
6169   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6170
6171   /* Dynamic linking info is on the func descriptor sym.  */
6172   fdh = defined_func_desc (eh);
6173   if (fdh != NULL)
6174     eh = fdh;
6175
6176   if ((eh->elf.root.type == bfd_link_hash_defined
6177        || eh->elf.root.type == bfd_link_hash_defweak)
6178       && (eh->elf.ref_dynamic
6179           || (eh->elf.def_regular
6180               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6181               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6182               && (!info->executable
6183                   || info->export_dynamic
6184                   || (eh->elf.dynamic
6185                       && d != NULL
6186                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6187               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6188                   || !bfd_hide_sym_by_version (info->version_info,
6189                                                eh->elf.root.root.string)))))
6190     {
6191       asection *code_sec;
6192       struct ppc_link_hash_entry *fh;
6193
6194       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6195
6196       /* Function descriptor syms cause the associated
6197          function code sym section to be marked.  */
6198       fh = defined_code_entry (eh);
6199       if (fh != NULL)
6200         {
6201           code_sec = fh->elf.root.u.def.section;
6202           code_sec->flags |= SEC_KEEP;
6203         }
6204       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6205                && opd_entry_value (eh->elf.root.u.def.section,
6206                                    eh->elf.root.u.def.value,
6207                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6208         code_sec->flags |= SEC_KEEP;
6209     }
6210
6211   return TRUE;
6212 }
6213
6214 /* Return the section that should be marked against GC for a given
6215    relocation.  */
6216
6217 static asection *
6218 ppc64_elf_gc_mark_hook (asection *sec,
6219                         struct bfd_link_info *info,
6220                         Elf_Internal_Rela *rel,
6221                         struct elf_link_hash_entry *h,
6222                         Elf_Internal_Sym *sym)
6223 {
6224   asection *rsec;
6225
6226   /* Syms return NULL if we're marking .opd, so we avoid marking all
6227      function sections, as all functions are referenced in .opd.  */
6228   rsec = NULL;
6229   if (get_opd_info (sec) != NULL)
6230     return rsec;
6231
6232   if (h != NULL)
6233     {
6234       enum elf_ppc64_reloc_type r_type;
6235       struct ppc_link_hash_entry *eh, *fh, *fdh;
6236
6237       r_type = ELF64_R_TYPE (rel->r_info);
6238       switch (r_type)
6239         {
6240         case R_PPC64_GNU_VTINHERIT:
6241         case R_PPC64_GNU_VTENTRY:
6242           break;
6243
6244         default:
6245           switch (h->root.type)
6246             {
6247             case bfd_link_hash_defined:
6248             case bfd_link_hash_defweak:
6249               eh = (struct ppc_link_hash_entry *) h;
6250               fdh = defined_func_desc (eh);
6251               if (fdh != NULL)
6252                 eh = fdh;
6253
6254               /* Function descriptor syms cause the associated
6255                  function code sym section to be marked.  */
6256               fh = defined_code_entry (eh);
6257               if (fh != NULL)
6258                 {
6259                   /* They also mark their opd section.  */
6260                   eh->elf.root.u.def.section->gc_mark = 1;
6261
6262                   rsec = fh->elf.root.u.def.section;
6263                 }
6264               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6265                        && opd_entry_value (eh->elf.root.u.def.section,
6266                                            eh->elf.root.u.def.value,
6267                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6268                 eh->elf.root.u.def.section->gc_mark = 1;
6269               else
6270                 rsec = h->root.u.def.section;
6271               break;
6272
6273             case bfd_link_hash_common:
6274               rsec = h->root.u.c.p->section;
6275               break;
6276
6277             default:
6278               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6279             }
6280         }
6281     }
6282   else
6283     {
6284       struct _opd_sec_data *opd;
6285
6286       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6287       opd = get_opd_info (rsec);
6288       if (opd != NULL && opd->func_sec != NULL)
6289         {
6290           rsec->gc_mark = 1;
6291
6292           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6293         }
6294     }
6295
6296   return rsec;
6297 }
6298
6299 /* Update the .got, .plt. and dynamic reloc reference counts for the
6300    section being removed.  */
6301
6302 static bfd_boolean
6303 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6304                          asection *sec, const Elf_Internal_Rela *relocs)
6305 {
6306   struct ppc_link_hash_table *htab;
6307   Elf_Internal_Shdr *symtab_hdr;
6308   struct elf_link_hash_entry **sym_hashes;
6309   struct got_entry **local_got_ents;
6310   const Elf_Internal_Rela *rel, *relend;
6311
6312   if (info->relocatable)
6313     return TRUE;
6314
6315   if ((sec->flags & SEC_ALLOC) == 0)
6316     return TRUE;
6317
6318   elf_section_data (sec)->local_dynrel = NULL;
6319
6320   htab = ppc_hash_table (info);
6321   if (htab == NULL)
6322     return FALSE;
6323
6324   symtab_hdr = &elf_symtab_hdr (abfd);
6325   sym_hashes = elf_sym_hashes (abfd);
6326   local_got_ents = elf_local_got_ents (abfd);
6327
6328   relend = relocs + sec->reloc_count;
6329   for (rel = relocs; rel < relend; rel++)
6330     {
6331       unsigned long r_symndx;
6332       enum elf_ppc64_reloc_type r_type;
6333       struct elf_link_hash_entry *h = NULL;
6334       unsigned char tls_type = 0;
6335
6336       r_symndx = ELF64_R_SYM (rel->r_info);
6337       r_type = ELF64_R_TYPE (rel->r_info);
6338       if (r_symndx >= symtab_hdr->sh_info)
6339         {
6340           struct ppc_link_hash_entry *eh;
6341           struct elf_dyn_relocs **pp;
6342           struct elf_dyn_relocs *p;
6343
6344           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6345           h = elf_follow_link (h);
6346           eh = (struct ppc_link_hash_entry *) h;
6347
6348           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6349             if (p->sec == sec)
6350               {
6351                 /* Everything must go for SEC.  */
6352                 *pp = p->next;
6353                 break;
6354               }
6355         }
6356
6357       if (is_branch_reloc (r_type))
6358         {
6359           struct plt_entry **ifunc = NULL;
6360           if (h != NULL)
6361             {
6362               if (h->type == STT_GNU_IFUNC)
6363                 ifunc = &h->plt.plist;
6364             }
6365           else if (local_got_ents != NULL)
6366             {
6367               struct plt_entry **local_plt = (struct plt_entry **)
6368                 (local_got_ents + symtab_hdr->sh_info);
6369               unsigned char *local_got_tls_masks = (unsigned char *)
6370                 (local_plt + symtab_hdr->sh_info);
6371               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6372                 ifunc = local_plt + r_symndx;
6373             }
6374           if (ifunc != NULL)
6375             {
6376               struct plt_entry *ent;
6377
6378               for (ent = *ifunc; ent != NULL; ent = ent->next)
6379                 if (ent->addend == rel->r_addend)
6380                   break;
6381               if (ent == NULL)
6382                 abort ();
6383               if (ent->plt.refcount > 0)
6384                 ent->plt.refcount -= 1;
6385               continue;
6386             }
6387         }
6388
6389       switch (r_type)
6390         {
6391         case R_PPC64_GOT_TLSLD16:
6392         case R_PPC64_GOT_TLSLD16_LO:
6393         case R_PPC64_GOT_TLSLD16_HI:
6394         case R_PPC64_GOT_TLSLD16_HA:
6395           tls_type = TLS_TLS | TLS_LD;
6396           goto dogot;
6397
6398         case R_PPC64_GOT_TLSGD16:
6399         case R_PPC64_GOT_TLSGD16_LO:
6400         case R_PPC64_GOT_TLSGD16_HI:
6401         case R_PPC64_GOT_TLSGD16_HA:
6402           tls_type = TLS_TLS | TLS_GD;
6403           goto dogot;
6404
6405         case R_PPC64_GOT_TPREL16_DS:
6406         case R_PPC64_GOT_TPREL16_LO_DS:
6407         case R_PPC64_GOT_TPREL16_HI:
6408         case R_PPC64_GOT_TPREL16_HA:
6409           tls_type = TLS_TLS | TLS_TPREL;
6410           goto dogot;
6411
6412         case R_PPC64_GOT_DTPREL16_DS:
6413         case R_PPC64_GOT_DTPREL16_LO_DS:
6414         case R_PPC64_GOT_DTPREL16_HI:
6415         case R_PPC64_GOT_DTPREL16_HA:
6416           tls_type = TLS_TLS | TLS_DTPREL;
6417           goto dogot;
6418
6419         case R_PPC64_GOT16:
6420         case R_PPC64_GOT16_DS:
6421         case R_PPC64_GOT16_HA:
6422         case R_PPC64_GOT16_HI:
6423         case R_PPC64_GOT16_LO:
6424         case R_PPC64_GOT16_LO_DS:
6425         dogot:
6426           {
6427             struct got_entry *ent;
6428
6429             if (h != NULL)
6430               ent = h->got.glist;
6431             else
6432               ent = local_got_ents[r_symndx];
6433
6434             for (; ent != NULL; ent = ent->next)
6435               if (ent->addend == rel->r_addend
6436                   && ent->owner == abfd
6437                   && ent->tls_type == tls_type)
6438                 break;
6439             if (ent == NULL)
6440               abort ();
6441             if (ent->got.refcount > 0)
6442               ent->got.refcount -= 1;
6443           }
6444           break;
6445
6446         case R_PPC64_PLT16_HA:
6447         case R_PPC64_PLT16_HI:
6448         case R_PPC64_PLT16_LO:
6449         case R_PPC64_PLT32:
6450         case R_PPC64_PLT64:
6451         case R_PPC64_REL14:
6452         case R_PPC64_REL14_BRNTAKEN:
6453         case R_PPC64_REL14_BRTAKEN:
6454         case R_PPC64_REL24:
6455           if (h != NULL)
6456             {
6457               struct plt_entry *ent;
6458
6459               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6460                 if (ent->addend == rel->r_addend)
6461                   break;
6462               if (ent != NULL && ent->plt.refcount > 0)
6463                 ent->plt.refcount -= 1;
6464             }
6465           break;
6466
6467         default:
6468           break;
6469         }
6470     }
6471   return TRUE;
6472 }
6473
6474 /* The maximum size of .sfpr.  */
6475 #define SFPR_MAX (218*4)
6476
6477 struct sfpr_def_parms
6478 {
6479   const char name[12];
6480   unsigned char lo, hi;
6481   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6482   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6483 };
6484
6485 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6486
6487 static bfd_boolean
6488 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6489 {
6490   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6491   unsigned int i;
6492   size_t len = strlen (parm->name);
6493   bfd_boolean writing = FALSE;
6494   char sym[16];
6495
6496   if (htab == NULL)
6497     return FALSE;
6498
6499   memcpy (sym, parm->name, len);
6500   sym[len + 2] = 0;
6501
6502   for (i = parm->lo; i <= parm->hi; i++)
6503     {
6504       struct elf_link_hash_entry *h;
6505
6506       sym[len + 0] = i / 10 + '0';
6507       sym[len + 1] = i % 10 + '0';
6508       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6509       if (h != NULL
6510           && !h->def_regular)
6511         {
6512           h->root.type = bfd_link_hash_defined;
6513           h->root.u.def.section = htab->sfpr;
6514           h->root.u.def.value = htab->sfpr->size;
6515           h->type = STT_FUNC;
6516           h->def_regular = 1;
6517           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6518           writing = TRUE;
6519           if (htab->sfpr->contents == NULL)
6520             {
6521               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6522               if (htab->sfpr->contents == NULL)
6523                 return FALSE;
6524             }
6525         }
6526       if (writing)
6527         {
6528           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6529           if (i != parm->hi)
6530             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6531           else
6532             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6533           htab->sfpr->size = p - htab->sfpr->contents;
6534         }
6535     }
6536
6537   return TRUE;
6538 }
6539
6540 static bfd_byte *
6541 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6542 {
6543   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6544   return p + 4;
6545 }
6546
6547 static bfd_byte *
6548 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6549 {
6550   p = savegpr0 (abfd, p, r);
6551   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6552   p = p + 4;
6553   bfd_put_32 (abfd, BLR, p);
6554   return p + 4;
6555 }
6556
6557 static bfd_byte *
6558 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6559 {
6560   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6561   return p + 4;
6562 }
6563
6564 static bfd_byte *
6565 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6566 {
6567   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6568   p = p + 4;
6569   p = restgpr0 (abfd, p, r);
6570   bfd_put_32 (abfd, MTLR_R0, p);
6571   p = p + 4;
6572   if (r == 29)
6573     {
6574       p = restgpr0 (abfd, p, 30);
6575       p = restgpr0 (abfd, p, 31);
6576     }
6577   bfd_put_32 (abfd, BLR, p);
6578   return p + 4;
6579 }
6580
6581 static bfd_byte *
6582 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6583 {
6584   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585   return p + 4;
6586 }
6587
6588 static bfd_byte *
6589 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591   p = savegpr1 (abfd, p, r);
6592   bfd_put_32 (abfd, BLR, p);
6593   return p + 4;
6594 }
6595
6596 static bfd_byte *
6597 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6598 {
6599   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6600   return p + 4;
6601 }
6602
6603 static bfd_byte *
6604 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6605 {
6606   p = restgpr1 (abfd, p, r);
6607   bfd_put_32 (abfd, BLR, p);
6608   return p + 4;
6609 }
6610
6611 static bfd_byte *
6612 savefpr (bfd *abfd, bfd_byte *p, int r)
6613 {
6614   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6615   return p + 4;
6616 }
6617
6618 static bfd_byte *
6619 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6620 {
6621   p = savefpr (abfd, p, r);
6622   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6623   p = p + 4;
6624   bfd_put_32 (abfd, BLR, p);
6625   return p + 4;
6626 }
6627
6628 static bfd_byte *
6629 restfpr (bfd *abfd, bfd_byte *p, int r)
6630 {
6631   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6632   return p + 4;
6633 }
6634
6635 static bfd_byte *
6636 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6637 {
6638   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6639   p = p + 4;
6640   p = restfpr (abfd, p, r);
6641   bfd_put_32 (abfd, MTLR_R0, p);
6642   p = p + 4;
6643   if (r == 29)
6644     {
6645       p = restfpr (abfd, p, 30);
6646       p = restfpr (abfd, p, 31);
6647     }
6648   bfd_put_32 (abfd, BLR, p);
6649   return p + 4;
6650 }
6651
6652 static bfd_byte *
6653 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6654 {
6655   p = savefpr (abfd, p, r);
6656   bfd_put_32 (abfd, BLR, p);
6657   return p + 4;
6658 }
6659
6660 static bfd_byte *
6661 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6662 {
6663   p = restfpr (abfd, p, r);
6664   bfd_put_32 (abfd, BLR, p);
6665   return p + 4;
6666 }
6667
6668 static bfd_byte *
6669 savevr (bfd *abfd, bfd_byte *p, int r)
6670 {
6671   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6672   p = p + 4;
6673   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6674   return p + 4;
6675 }
6676
6677 static bfd_byte *
6678 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6679 {
6680   p = savevr (abfd, p, r);
6681   bfd_put_32 (abfd, BLR, p);
6682   return p + 4;
6683 }
6684
6685 static bfd_byte *
6686 restvr (bfd *abfd, bfd_byte *p, int r)
6687 {
6688   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6689   p = p + 4;
6690   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6691   return p + 4;
6692 }
6693
6694 static bfd_byte *
6695 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6696 {
6697   p = restvr (abfd, p, r);
6698   bfd_put_32 (abfd, BLR, p);
6699   return p + 4;
6700 }
6701
6702 /* Called via elf_link_hash_traverse to transfer dynamic linking
6703    information on function code symbol entries to their corresponding
6704    function descriptor symbol entries.  */
6705
6706 static bfd_boolean
6707 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6708 {
6709   struct bfd_link_info *info;
6710   struct ppc_link_hash_table *htab;
6711   struct plt_entry *ent;
6712   struct ppc_link_hash_entry *fh;
6713   struct ppc_link_hash_entry *fdh;
6714   bfd_boolean force_local;
6715
6716   fh = (struct ppc_link_hash_entry *) h;
6717   if (fh->elf.root.type == bfd_link_hash_indirect)
6718     return TRUE;
6719
6720   info = inf;
6721   htab = ppc_hash_table (info);
6722   if (htab == NULL)
6723     return FALSE;
6724
6725   /* Resolve undefined references to dot-symbols as the value
6726      in the function descriptor, if we have one in a regular object.
6727      This is to satisfy cases like ".quad .foo".  Calls to functions
6728      in dynamic objects are handled elsewhere.  */
6729   if (fh->elf.root.type == bfd_link_hash_undefweak
6730       && fh->was_undefined
6731       && (fdh = defined_func_desc (fh)) != NULL
6732       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6733       && opd_entry_value (fdh->elf.root.u.def.section,
6734                           fdh->elf.root.u.def.value,
6735                           &fh->elf.root.u.def.section,
6736                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6737     {
6738       fh->elf.root.type = fdh->elf.root.type;
6739       fh->elf.forced_local = 1;
6740       fh->elf.def_regular = fdh->elf.def_regular;
6741       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6742     }
6743
6744   /* If this is a function code symbol, transfer dynamic linking
6745      information to the function descriptor symbol.  */
6746   if (!fh->is_func)
6747     return TRUE;
6748
6749   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6750     if (ent->plt.refcount > 0)
6751       break;
6752   if (ent == NULL
6753       || fh->elf.root.root.string[0] != '.'
6754       || fh->elf.root.root.string[1] == '\0')
6755     return TRUE;
6756
6757   /* Find the corresponding function descriptor symbol.  Create it
6758      as undefined if necessary.  */
6759
6760   fdh = lookup_fdh (fh, htab);
6761   if (fdh == NULL
6762       && !info->executable
6763       && (fh->elf.root.type == bfd_link_hash_undefined
6764           || fh->elf.root.type == bfd_link_hash_undefweak))
6765     {
6766       fdh = make_fdh (info, fh);
6767       if (fdh == NULL)
6768         return FALSE;
6769     }
6770
6771   /* Fake function descriptors are made undefweak.  If the function
6772      code symbol is strong undefined, make the fake sym the same.
6773      If the function code symbol is defined, then force the fake
6774      descriptor local;  We can't support overriding of symbols in a
6775      shared library on a fake descriptor.  */
6776
6777   if (fdh != NULL
6778       && fdh->fake
6779       && fdh->elf.root.type == bfd_link_hash_undefweak)
6780     {
6781       if (fh->elf.root.type == bfd_link_hash_undefined)
6782         {
6783           fdh->elf.root.type = bfd_link_hash_undefined;
6784           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6785         }
6786       else if (fh->elf.root.type == bfd_link_hash_defined
6787                || fh->elf.root.type == bfd_link_hash_defweak)
6788         {
6789           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6790         }
6791     }
6792
6793   if (fdh != NULL
6794       && !fdh->elf.forced_local
6795       && (!info->executable
6796           || fdh->elf.def_dynamic
6797           || fdh->elf.ref_dynamic
6798           || (fdh->elf.root.type == bfd_link_hash_undefweak
6799               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6800     {
6801       if (fdh->elf.dynindx == -1)
6802         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6803           return FALSE;
6804       fdh->elf.ref_regular |= fh->elf.ref_regular;
6805       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6806       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6807       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6808       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6809         {
6810           move_plt_plist (fh, fdh);
6811           fdh->elf.needs_plt = 1;
6812         }
6813       fdh->is_func_descriptor = 1;
6814       fdh->oh = fh;
6815       fh->oh = fdh;
6816     }
6817
6818   /* Now that the info is on the function descriptor, clear the
6819      function code sym info.  Any function code syms for which we
6820      don't have a definition in a regular file, we force local.
6821      This prevents a shared library from exporting syms that have
6822      been imported from another library.  Function code syms that
6823      are really in the library we must leave global to prevent the
6824      linker dragging in a definition from a static library.  */
6825   force_local = (!fh->elf.def_regular
6826                  || fdh == NULL
6827                  || !fdh->elf.def_regular
6828                  || fdh->elf.forced_local);
6829   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6830
6831   return TRUE;
6832 }
6833
6834 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6835    this hook to a) provide some gcc support functions, and b) transfer
6836    dynamic linking information gathered so far on function code symbol
6837    entries, to their corresponding function descriptor symbol entries.  */
6838
6839 static bfd_boolean
6840 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6841                             struct bfd_link_info *info)
6842 {
6843   struct ppc_link_hash_table *htab;
6844   unsigned int i;
6845   static const struct sfpr_def_parms funcs[] =
6846     {
6847       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6848       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6849       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6850       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6851       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6852       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6853       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6854       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6855       { "._savef", 14, 31, savefpr, savefpr1_tail },
6856       { "._restf", 14, 31, restfpr, restfpr1_tail },
6857       { "_savevr_", 20, 31, savevr, savevr_tail },
6858       { "_restvr_", 20, 31, restvr, restvr_tail }
6859     };
6860
6861   htab = ppc_hash_table (info);
6862   if (htab == NULL)
6863     return FALSE;
6864
6865   if (!info->relocatable
6866       && htab->elf.hgot != NULL)
6867     {
6868       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6869       /* Make .TOC. defined so as to prevent it being made dynamic.
6870          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6871       htab->elf.hgot->type = STT_OBJECT;
6872       htab->elf.hgot->root.type = bfd_link_hash_defined;
6873       htab->elf.hgot->root.u.def.value = 0;
6874       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6875       htab->elf.hgot->def_regular = 1;
6876       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6877                                | STV_HIDDEN);
6878     }
6879
6880   if (htab->sfpr == NULL)
6881     /* We don't have any relocs.  */
6882     return TRUE;
6883
6884   /* Provide any missing _save* and _rest* functions.  */
6885   htab->sfpr->size = 0;
6886   if (htab->params->save_restore_funcs)
6887     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6888       if (!sfpr_define (info, &funcs[i]))
6889         return FALSE;
6890
6891   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6892
6893   if (htab->sfpr->size == 0)
6894     htab->sfpr->flags |= SEC_EXCLUDE;
6895
6896   return TRUE;
6897 }
6898
6899 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6900
6901 static bfd_boolean
6902 readonly_dynrelocs (struct elf_link_hash_entry *h)
6903 {
6904   struct ppc_link_hash_entry *eh;
6905   struct elf_dyn_relocs *p;
6906
6907   eh = (struct ppc_link_hash_entry *) h;
6908   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6909     {
6910       asection *s = p->sec->output_section;
6911
6912       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6913         return TRUE;
6914     }
6915   return FALSE;
6916 }
6917
6918 /* Adjust a symbol defined by a dynamic object and referenced by a
6919    regular object.  The current definition is in some section of the
6920    dynamic object, but we're not including those sections.  We have to
6921    change the definition to something the rest of the link can
6922    understand.  */
6923
6924 static bfd_boolean
6925 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6926                                  struct elf_link_hash_entry *h)
6927 {
6928   struct ppc_link_hash_table *htab;
6929   asection *s;
6930
6931   htab = ppc_hash_table (info);
6932   if (htab == NULL)
6933     return FALSE;
6934
6935   /* Deal with function syms.  */
6936   if (h->type == STT_FUNC
6937       || h->type == STT_GNU_IFUNC
6938       || h->needs_plt)
6939     {
6940       /* Clear procedure linkage table information for any symbol that
6941          won't need a .plt entry.  */
6942       struct plt_entry *ent;
6943       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6944         if (ent->plt.refcount > 0)
6945           break;
6946       if (ent == NULL
6947           || (h->type != STT_GNU_IFUNC
6948               && (SYMBOL_CALLS_LOCAL (info, h)
6949                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6950                       && h->root.type == bfd_link_hash_undefweak))))
6951         {
6952           h->plt.plist = NULL;
6953           h->needs_plt = 0;
6954         }
6955       else if (abiversion (info->output_bfd) == 2)
6956         {
6957           /* After adjust_dynamic_symbol, non_got_ref set in the
6958              non-shared case means that we have allocated space in
6959              .dynbss for the symbol and thus dyn_relocs for this
6960              symbol should be discarded.
6961              If we get here we know we are making a PLT entry for this
6962              symbol, and in an executable we'd normally resolve
6963              relocations against this symbol to the PLT entry.  Allow
6964              dynamic relocs if the reference is weak, and the dynamic
6965              relocs will not cause text relocation.  */
6966           if (!h->ref_regular_nonweak
6967               && h->non_got_ref
6968               && h->type != STT_GNU_IFUNC
6969               && !readonly_dynrelocs (h))
6970             h->non_got_ref = 0;
6971
6972           /* If making a plt entry, then we don't need copy relocs.  */
6973           return TRUE;
6974         }
6975     }
6976   else
6977     h->plt.plist = NULL;
6978
6979   /* If this is a weak symbol, and there is a real definition, the
6980      processor independent code will have arranged for us to see the
6981      real definition first, and we can just use the same value.  */
6982   if (h->u.weakdef != NULL)
6983     {
6984       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6985                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6986       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6987       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6988       if (ELIMINATE_COPY_RELOCS)
6989         h->non_got_ref = h->u.weakdef->non_got_ref;
6990       return TRUE;
6991     }
6992
6993   /* If we are creating a shared library, we must presume that the
6994      only references to the symbol are via the global offset table.
6995      For such cases we need not do anything here; the relocations will
6996      be handled correctly by relocate_section.  */
6997   if (info->shared)
6998     return TRUE;
6999
7000   /* If there are no references to this symbol that do not use the
7001      GOT, we don't need to generate a copy reloc.  */
7002   if (!h->non_got_ref)
7003     return TRUE;
7004
7005   /* Don't generate a copy reloc for symbols defined in the executable.  */
7006   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7007     return TRUE;
7008
7009   /* If we didn't find any dynamic relocs in read-only sections, then
7010      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7011   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7012     {
7013       h->non_got_ref = 0;
7014       return TRUE;
7015     }
7016
7017   if (h->plt.plist != NULL)
7018     {
7019       /* We should never get here, but unfortunately there are versions
7020          of gcc out there that improperly (for this ABI) put initialized
7021          function pointers, vtable refs and suchlike in read-only
7022          sections.  Allow them to proceed, but warn that this might
7023          break at runtime.  */
7024       info->callbacks->einfo
7025         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7026            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7027          h->root.root.string);
7028     }
7029
7030   /* This is a reference to a symbol defined by a dynamic object which
7031      is not a function.  */
7032
7033   /* We must allocate the symbol in our .dynbss section, which will
7034      become part of the .bss section of the executable.  There will be
7035      an entry for this symbol in the .dynsym section.  The dynamic
7036      object will contain position independent code, so all references
7037      from the dynamic object to this symbol will go through the global
7038      offset table.  The dynamic linker will use the .dynsym entry to
7039      determine the address it must put in the global offset table, so
7040      both the dynamic object and the regular object will refer to the
7041      same memory location for the variable.  */
7042
7043   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7044      to copy the initial value out of the dynamic object and into the
7045      runtime process image.  We need to remember the offset into the
7046      .rela.bss section we are going to use.  */
7047   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7048     {
7049       htab->relbss->size += sizeof (Elf64_External_Rela);
7050       h->needs_copy = 1;
7051     }
7052
7053   s = htab->dynbss;
7054
7055   return _bfd_elf_adjust_dynamic_copy (h, s);
7056 }
7057
7058 /* If given a function descriptor symbol, hide both the function code
7059    sym and the descriptor.  */
7060 static void
7061 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7062                        struct elf_link_hash_entry *h,
7063                        bfd_boolean force_local)
7064 {
7065   struct ppc_link_hash_entry *eh;
7066   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7067
7068   eh = (struct ppc_link_hash_entry *) h;
7069   if (eh->is_func_descriptor)
7070     {
7071       struct ppc_link_hash_entry *fh = eh->oh;
7072
7073       if (fh == NULL)
7074         {
7075           const char *p, *q;
7076           struct ppc_link_hash_table *htab;
7077           char save;
7078
7079           /* We aren't supposed to use alloca in BFD because on
7080              systems which do not have alloca the version in libiberty
7081              calls xmalloc, which might cause the program to crash
7082              when it runs out of memory.  This function doesn't have a
7083              return status, so there's no way to gracefully return an
7084              error.  So cheat.  We know that string[-1] can be safely
7085              accessed;  It's either a string in an ELF string table,
7086              or allocated in an objalloc structure.  */
7087
7088           p = eh->elf.root.root.string - 1;
7089           save = *p;
7090           *(char *) p = '.';
7091           htab = ppc_hash_table (info);
7092           if (htab == NULL)
7093             return;
7094
7095           fh = (struct ppc_link_hash_entry *)
7096             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7097           *(char *) p = save;
7098
7099           /* Unfortunately, if it so happens that the string we were
7100              looking for was allocated immediately before this string,
7101              then we overwrote the string terminator.  That's the only
7102              reason the lookup should fail.  */
7103           if (fh == NULL)
7104             {
7105               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7106               while (q >= eh->elf.root.root.string && *q == *p)
7107                 --q, --p;
7108               if (q < eh->elf.root.root.string && *p == '.')
7109                 fh = (struct ppc_link_hash_entry *)
7110                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7111             }
7112           if (fh != NULL)
7113             {
7114               eh->oh = fh;
7115               fh->oh = eh;
7116             }
7117         }
7118       if (fh != NULL)
7119         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7120     }
7121 }
7122
7123 static bfd_boolean
7124 get_sym_h (struct elf_link_hash_entry **hp,
7125            Elf_Internal_Sym **symp,
7126            asection **symsecp,
7127            unsigned char **tls_maskp,
7128            Elf_Internal_Sym **locsymsp,
7129            unsigned long r_symndx,
7130            bfd *ibfd)
7131 {
7132   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7133
7134   if (r_symndx >= symtab_hdr->sh_info)
7135     {
7136       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7137       struct elf_link_hash_entry *h;
7138
7139       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7140       h = elf_follow_link (h);
7141
7142       if (hp != NULL)
7143         *hp = h;
7144
7145       if (symp != NULL)
7146         *symp = NULL;
7147
7148       if (symsecp != NULL)
7149         {
7150           asection *symsec = NULL;
7151           if (h->root.type == bfd_link_hash_defined
7152               || h->root.type == bfd_link_hash_defweak)
7153             symsec = h->root.u.def.section;
7154           *symsecp = symsec;
7155         }
7156
7157       if (tls_maskp != NULL)
7158         {
7159           struct ppc_link_hash_entry *eh;
7160
7161           eh = (struct ppc_link_hash_entry *) h;
7162           *tls_maskp = &eh->tls_mask;
7163         }
7164     }
7165   else
7166     {
7167       Elf_Internal_Sym *sym;
7168       Elf_Internal_Sym *locsyms = *locsymsp;
7169
7170       if (locsyms == NULL)
7171         {
7172           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7173           if (locsyms == NULL)
7174             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7175                                             symtab_hdr->sh_info,
7176                                             0, NULL, NULL, NULL);
7177           if (locsyms == NULL)
7178             return FALSE;
7179           *locsymsp = locsyms;
7180         }
7181       sym = locsyms + r_symndx;
7182
7183       if (hp != NULL)
7184         *hp = NULL;
7185
7186       if (symp != NULL)
7187         *symp = sym;
7188
7189       if (symsecp != NULL)
7190         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7191
7192       if (tls_maskp != NULL)
7193         {
7194           struct got_entry **lgot_ents;
7195           unsigned char *tls_mask;
7196
7197           tls_mask = NULL;
7198           lgot_ents = elf_local_got_ents (ibfd);
7199           if (lgot_ents != NULL)
7200             {
7201               struct plt_entry **local_plt = (struct plt_entry **)
7202                 (lgot_ents + symtab_hdr->sh_info);
7203               unsigned char *lgot_masks = (unsigned char *)
7204                 (local_plt + symtab_hdr->sh_info);
7205               tls_mask = &lgot_masks[r_symndx];
7206             }
7207           *tls_maskp = tls_mask;
7208         }
7209     }
7210   return TRUE;
7211 }
7212
7213 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7214    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7215    type suitable for optimization, and 1 otherwise.  */
7216
7217 static int
7218 get_tls_mask (unsigned char **tls_maskp,
7219               unsigned long *toc_symndx,
7220               bfd_vma *toc_addend,
7221               Elf_Internal_Sym **locsymsp,
7222               const Elf_Internal_Rela *rel,
7223               bfd *ibfd)
7224 {
7225   unsigned long r_symndx;
7226   int next_r;
7227   struct elf_link_hash_entry *h;
7228   Elf_Internal_Sym *sym;
7229   asection *sec;
7230   bfd_vma off;
7231
7232   r_symndx = ELF64_R_SYM (rel->r_info);
7233   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7234     return 0;
7235
7236   if ((*tls_maskp != NULL && **tls_maskp != 0)
7237       || sec == NULL
7238       || ppc64_elf_section_data (sec) == NULL
7239       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7240     return 1;
7241
7242   /* Look inside a TOC section too.  */
7243   if (h != NULL)
7244     {
7245       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7246       off = h->root.u.def.value;
7247     }
7248   else
7249     off = sym->st_value;
7250   off += rel->r_addend;
7251   BFD_ASSERT (off % 8 == 0);
7252   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7253   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7254   if (toc_symndx != NULL)
7255     *toc_symndx = r_symndx;
7256   if (toc_addend != NULL)
7257     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7258   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7259     return 0;
7260   if ((h == NULL || is_static_defined (h))
7261       && (next_r == -1 || next_r == -2))
7262     return 1 - next_r;
7263   return 1;
7264 }
7265
7266 /* Find (or create) an entry in the tocsave hash table.  */
7267
7268 static struct tocsave_entry *
7269 tocsave_find (struct ppc_link_hash_table *htab,
7270               enum insert_option insert,
7271               Elf_Internal_Sym **local_syms,
7272               const Elf_Internal_Rela *irela,
7273               bfd *ibfd)
7274 {
7275   unsigned long r_indx;
7276   struct elf_link_hash_entry *h;
7277   Elf_Internal_Sym *sym;
7278   struct tocsave_entry ent, *p;
7279   hashval_t hash;
7280   struct tocsave_entry **slot;
7281
7282   r_indx = ELF64_R_SYM (irela->r_info);
7283   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7284     return NULL;
7285   if (ent.sec == NULL || ent.sec->output_section == NULL)
7286     {
7287       (*_bfd_error_handler)
7288         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7289       return NULL;
7290     }
7291
7292   if (h != NULL)
7293     ent.offset = h->root.u.def.value;
7294   else
7295     ent.offset = sym->st_value;
7296   ent.offset += irela->r_addend;
7297
7298   hash = tocsave_htab_hash (&ent);
7299   slot = ((struct tocsave_entry **)
7300           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7301   if (slot == NULL)
7302     return NULL;
7303
7304   if (*slot == NULL)
7305     {
7306       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7307       if (p == NULL)
7308         return NULL;
7309       *p = ent;
7310       *slot = p;
7311     }
7312   return *slot;
7313 }
7314
7315 /* Adjust all global syms defined in opd sections.  In gcc generated
7316    code for the old ABI, these will already have been done.  */
7317
7318 static bfd_boolean
7319 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7320 {
7321   struct ppc_link_hash_entry *eh;
7322   asection *sym_sec;
7323   struct _opd_sec_data *opd;
7324
7325   if (h->root.type == bfd_link_hash_indirect)
7326     return TRUE;
7327
7328   if (h->root.type != bfd_link_hash_defined
7329       && h->root.type != bfd_link_hash_defweak)
7330     return TRUE;
7331
7332   eh = (struct ppc_link_hash_entry *) h;
7333   if (eh->adjust_done)
7334     return TRUE;
7335
7336   sym_sec = eh->elf.root.u.def.section;
7337   opd = get_opd_info (sym_sec);
7338   if (opd != NULL && opd->adjust != NULL)
7339     {
7340       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7341       if (adjust == -1)
7342         {
7343           /* This entry has been deleted.  */
7344           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7345           if (dsec == NULL)
7346             {
7347               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7348                 if (discarded_section (dsec))
7349                   {
7350                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7351                     break;
7352                   }
7353             }
7354           eh->elf.root.u.def.value = 0;
7355           eh->elf.root.u.def.section = dsec;
7356         }
7357       else
7358         eh->elf.root.u.def.value += adjust;
7359       eh->adjust_done = 1;
7360     }
7361   return TRUE;
7362 }
7363
7364 /* Handles decrementing dynamic reloc counts for the reloc specified by
7365    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7366    have already been determined.  */
7367
7368 static bfd_boolean
7369 dec_dynrel_count (bfd_vma r_info,
7370                   asection *sec,
7371                   struct bfd_link_info *info,
7372                   Elf_Internal_Sym **local_syms,
7373                   struct elf_link_hash_entry *h,
7374                   Elf_Internal_Sym *sym)
7375 {
7376   enum elf_ppc64_reloc_type r_type;
7377   asection *sym_sec = NULL;
7378
7379   /* Can this reloc be dynamic?  This switch, and later tests here
7380      should be kept in sync with the code in check_relocs.  */
7381   r_type = ELF64_R_TYPE (r_info);
7382   switch (r_type)
7383     {
7384     default:
7385       return TRUE;
7386
7387     case R_PPC64_TPREL16:
7388     case R_PPC64_TPREL16_LO:
7389     case R_PPC64_TPREL16_HI:
7390     case R_PPC64_TPREL16_HA:
7391     case R_PPC64_TPREL16_DS:
7392     case R_PPC64_TPREL16_LO_DS:
7393     case R_PPC64_TPREL16_HIGH:
7394     case R_PPC64_TPREL16_HIGHA:
7395     case R_PPC64_TPREL16_HIGHER:
7396     case R_PPC64_TPREL16_HIGHERA:
7397     case R_PPC64_TPREL16_HIGHEST:
7398     case R_PPC64_TPREL16_HIGHESTA:
7399       if (!info->shared)
7400         return TRUE;
7401
7402     case R_PPC64_TPREL64:
7403     case R_PPC64_DTPMOD64:
7404     case R_PPC64_DTPREL64:
7405     case R_PPC64_ADDR64:
7406     case R_PPC64_REL30:
7407     case R_PPC64_REL32:
7408     case R_PPC64_REL64:
7409     case R_PPC64_ADDR14:
7410     case R_PPC64_ADDR14_BRNTAKEN:
7411     case R_PPC64_ADDR14_BRTAKEN:
7412     case R_PPC64_ADDR16:
7413     case R_PPC64_ADDR16_DS:
7414     case R_PPC64_ADDR16_HA:
7415     case R_PPC64_ADDR16_HI:
7416     case R_PPC64_ADDR16_HIGH:
7417     case R_PPC64_ADDR16_HIGHA:
7418     case R_PPC64_ADDR16_HIGHER:
7419     case R_PPC64_ADDR16_HIGHERA:
7420     case R_PPC64_ADDR16_HIGHEST:
7421     case R_PPC64_ADDR16_HIGHESTA:
7422     case R_PPC64_ADDR16_LO:
7423     case R_PPC64_ADDR16_LO_DS:
7424     case R_PPC64_ADDR24:
7425     case R_PPC64_ADDR32:
7426     case R_PPC64_UADDR16:
7427     case R_PPC64_UADDR32:
7428     case R_PPC64_UADDR64:
7429     case R_PPC64_TOC:
7430       break;
7431     }
7432
7433   if (local_syms != NULL)
7434     {
7435       unsigned long r_symndx;
7436       bfd *ibfd = sec->owner;
7437
7438       r_symndx = ELF64_R_SYM (r_info);
7439       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7440         return FALSE;
7441     }
7442
7443   if ((info->shared
7444        && (must_be_dyn_reloc (info, r_type)
7445            || (h != NULL
7446                && (!SYMBOLIC_BIND (info, h)
7447                    || h->root.type == bfd_link_hash_defweak
7448                    || !h->def_regular))))
7449       || (ELIMINATE_COPY_RELOCS
7450           && !info->shared
7451           && h != NULL
7452           && (h->root.type == bfd_link_hash_defweak
7453               || !h->def_regular)))
7454     ;
7455   else
7456     return TRUE;
7457
7458   if (h != NULL)
7459     {
7460       struct elf_dyn_relocs *p;
7461       struct elf_dyn_relocs **pp;
7462       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7463
7464       /* elf_gc_sweep may have already removed all dyn relocs associated
7465          with local syms for a given section.  Also, symbol flags are
7466          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7467          report a dynreloc miscount.  */
7468       if (*pp == NULL && info->gc_sections)
7469         return TRUE;
7470
7471       while ((p = *pp) != NULL)
7472         {
7473           if (p->sec == sec)
7474             {
7475               if (!must_be_dyn_reloc (info, r_type))
7476                 p->pc_count -= 1;
7477               p->count -= 1;
7478               if (p->count == 0)
7479                 *pp = p->next;
7480               return TRUE;
7481             }
7482           pp = &p->next;
7483         }
7484     }
7485   else
7486     {
7487       struct ppc_dyn_relocs *p;
7488       struct ppc_dyn_relocs **pp;
7489       void *vpp;
7490       bfd_boolean is_ifunc;
7491
7492       if (local_syms == NULL)
7493         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7494       if (sym_sec == NULL)
7495         sym_sec = sec;
7496
7497       vpp = &elf_section_data (sym_sec)->local_dynrel;
7498       pp = (struct ppc_dyn_relocs **) vpp;
7499
7500       if (*pp == NULL && info->gc_sections)
7501         return TRUE;
7502
7503       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7504       while ((p = *pp) != NULL)
7505         {
7506           if (p->sec == sec && p->ifunc == is_ifunc)
7507             {
7508               p->count -= 1;
7509               if (p->count == 0)
7510                 *pp = p->next;
7511               return TRUE;
7512             }
7513           pp = &p->next;
7514         }
7515     }
7516
7517   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7518                           sec->owner, sec);
7519   bfd_set_error (bfd_error_bad_value);
7520   return FALSE;
7521 }
7522
7523 /* Remove unused Official Procedure Descriptor entries.  Currently we
7524    only remove those associated with functions in discarded link-once
7525    sections, or weakly defined functions that have been overridden.  It
7526    would be possible to remove many more entries for statically linked
7527    applications.  */
7528
7529 bfd_boolean
7530 ppc64_elf_edit_opd (struct bfd_link_info *info)
7531 {
7532   bfd *ibfd;
7533   bfd_boolean some_edited = FALSE;
7534   asection *need_pad = NULL;
7535   struct ppc_link_hash_table *htab;
7536
7537   htab = ppc_hash_table (info);
7538   if (htab == NULL)
7539     return FALSE;
7540
7541   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7542     {
7543       asection *sec;
7544       Elf_Internal_Rela *relstart, *rel, *relend;
7545       Elf_Internal_Shdr *symtab_hdr;
7546       Elf_Internal_Sym *local_syms;
7547       bfd_vma offset;
7548       struct _opd_sec_data *opd;
7549       bfd_boolean need_edit, add_aux_fields;
7550       bfd_size_type cnt_16b = 0;
7551
7552       if (!is_ppc64_elf (ibfd))
7553         continue;
7554
7555       sec = bfd_get_section_by_name (ibfd, ".opd");
7556       if (sec == NULL || sec->size == 0)
7557         continue;
7558
7559       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7560         continue;
7561
7562       if (sec->output_section == bfd_abs_section_ptr)
7563         continue;
7564
7565       /* Look through the section relocs.  */
7566       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7567         continue;
7568
7569       local_syms = NULL;
7570       symtab_hdr = &elf_symtab_hdr (ibfd);
7571
7572       /* Read the relocations.  */
7573       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7574                                             info->keep_memory);
7575       if (relstart == NULL)
7576         return FALSE;
7577
7578       /* First run through the relocs to check they are sane, and to
7579          determine whether we need to edit this opd section.  */
7580       need_edit = FALSE;
7581       need_pad = sec;
7582       offset = 0;
7583       relend = relstart + sec->reloc_count;
7584       for (rel = relstart; rel < relend; )
7585         {
7586           enum elf_ppc64_reloc_type r_type;
7587           unsigned long r_symndx;
7588           asection *sym_sec;
7589           struct elf_link_hash_entry *h;
7590           Elf_Internal_Sym *sym;
7591
7592           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7593              only interested in the reloc pointing to a function entry
7594              point.  */
7595           if (rel->r_offset != offset
7596               || rel + 1 >= relend
7597               || (rel + 1)->r_offset != offset + 8)
7598             {
7599               /* If someone messes with .opd alignment then after a
7600                  "ld -r" we might have padding in the middle of .opd.
7601                  Also, there's nothing to prevent someone putting
7602                  something silly in .opd with the assembler.  No .opd
7603                  optimization for them!  */
7604             broken_opd:
7605               (*_bfd_error_handler)
7606                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7607               need_edit = FALSE;
7608               break;
7609             }
7610
7611           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7612               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7613             {
7614               (*_bfd_error_handler)
7615                 (_("%B: unexpected reloc type %u in .opd section"),
7616                  ibfd, r_type);
7617               need_edit = FALSE;
7618               break;
7619             }
7620
7621           r_symndx = ELF64_R_SYM (rel->r_info);
7622           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7623                           r_symndx, ibfd))
7624             goto error_ret;
7625
7626           if (sym_sec == NULL || sym_sec->owner == NULL)
7627             {
7628               const char *sym_name;
7629               if (h != NULL)
7630                 sym_name = h->root.root.string;
7631               else
7632                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7633                                              sym_sec);
7634
7635               (*_bfd_error_handler)
7636                 (_("%B: undefined sym `%s' in .opd section"),
7637                  ibfd, sym_name);
7638               need_edit = FALSE;
7639               break;
7640             }
7641
7642           /* opd entries are always for functions defined in the
7643              current input bfd.  If the symbol isn't defined in the
7644              input bfd, then we won't be using the function in this
7645              bfd;  It must be defined in a linkonce section in another
7646              bfd, or is weak.  It's also possible that we are
7647              discarding the function due to a linker script /DISCARD/,
7648              which we test for via the output_section.  */
7649           if (sym_sec->owner != ibfd
7650               || sym_sec->output_section == bfd_abs_section_ptr)
7651             need_edit = TRUE;
7652
7653           rel += 2;
7654           if (rel == relend
7655               || (rel + 1 == relend && rel->r_offset == offset + 16))
7656             {
7657               if (sec->size == offset + 24)
7658                 {
7659                   need_pad = NULL;
7660                   break;
7661                 }
7662               if (rel == relend && sec->size == offset + 16)
7663                 {
7664                   cnt_16b++;
7665                   break;
7666                 }
7667               goto broken_opd;
7668             }
7669
7670           if (rel->r_offset == offset + 24)
7671             offset += 24;
7672           else if (rel->r_offset != offset + 16)
7673             goto broken_opd;
7674           else if (rel + 1 < relend
7675                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7676                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7677             {
7678               offset += 16;
7679               cnt_16b++;
7680             }
7681           else if (rel + 2 < relend
7682                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7683                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7684             {
7685               offset += 24;
7686               rel += 1;
7687             }
7688           else
7689             goto broken_opd;
7690         }
7691
7692       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7693
7694       if (need_edit || add_aux_fields)
7695         {
7696           Elf_Internal_Rela *write_rel;
7697           Elf_Internal_Shdr *rel_hdr;
7698           bfd_byte *rptr, *wptr;
7699           bfd_byte *new_contents;
7700           bfd_boolean skip;
7701           long opd_ent_size;
7702           bfd_size_type amt;
7703
7704           new_contents = NULL;
7705           amt = sec->size * sizeof (long) / 8;
7706           opd = &ppc64_elf_section_data (sec)->u.opd;
7707           opd->adjust = bfd_zalloc (sec->owner, amt);
7708           if (opd->adjust == NULL)
7709             return FALSE;
7710           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7711
7712           /* This seems a waste of time as input .opd sections are all
7713              zeros as generated by gcc, but I suppose there's no reason
7714              this will always be so.  We might start putting something in
7715              the third word of .opd entries.  */
7716           if ((sec->flags & SEC_IN_MEMORY) == 0)
7717             {
7718               bfd_byte *loc;
7719               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7720                 {
7721                   if (loc != NULL)
7722                     free (loc);
7723                 error_ret:
7724                   if (local_syms != NULL
7725                       && symtab_hdr->contents != (unsigned char *) local_syms)
7726                     free (local_syms);
7727                   if (elf_section_data (sec)->relocs != relstart)
7728                     free (relstart);
7729                   return FALSE;
7730                 }
7731               sec->contents = loc;
7732               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7733             }
7734
7735           elf_section_data (sec)->relocs = relstart;
7736
7737           new_contents = sec->contents;
7738           if (add_aux_fields)
7739             {
7740               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7741               if (new_contents == NULL)
7742                 return FALSE;
7743               need_pad = FALSE;
7744             }
7745           wptr = new_contents;
7746           rptr = sec->contents;
7747
7748           write_rel = relstart;
7749           skip = FALSE;
7750           offset = 0;
7751           opd_ent_size = 0;
7752           for (rel = relstart; rel < relend; rel++)
7753             {
7754               unsigned long r_symndx;
7755               asection *sym_sec;
7756               struct elf_link_hash_entry *h;
7757               Elf_Internal_Sym *sym;
7758
7759               r_symndx = ELF64_R_SYM (rel->r_info);
7760               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7761                               r_symndx, ibfd))
7762                 goto error_ret;
7763
7764               if (rel->r_offset == offset)
7765                 {
7766                   struct ppc_link_hash_entry *fdh = NULL;
7767
7768                   /* See if the .opd entry is full 24 byte or
7769                      16 byte (with fd_aux entry overlapped with next
7770                      fd_func).  */
7771                   opd_ent_size = 24;
7772                   if ((rel + 2 == relend && sec->size == offset + 16)
7773                       || (rel + 3 < relend
7774                           && rel[2].r_offset == offset + 16
7775                           && rel[3].r_offset == offset + 24
7776                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7777                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7778                     opd_ent_size = 16;
7779
7780                   if (h != NULL
7781                       && h->root.root.string[0] == '.')
7782                     {
7783                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7784                       if (fdh != NULL
7785                           && fdh->elf.root.type != bfd_link_hash_defined
7786                           && fdh->elf.root.type != bfd_link_hash_defweak)
7787                         fdh = NULL;
7788                     }
7789
7790                   skip = (sym_sec->owner != ibfd
7791                           || sym_sec->output_section == bfd_abs_section_ptr);
7792                   if (skip)
7793                     {
7794                       if (fdh != NULL && sym_sec->owner == ibfd)
7795                         {
7796                           /* Arrange for the function descriptor sym
7797                              to be dropped.  */
7798                           fdh->elf.root.u.def.value = 0;
7799                           fdh->elf.root.u.def.section = sym_sec;
7800                         }
7801                       opd->adjust[rel->r_offset / 8] = -1;
7802                     }
7803                   else
7804                     {
7805                       /* We'll be keeping this opd entry.  */
7806
7807                       if (fdh != NULL)
7808                         {
7809                           /* Redefine the function descriptor symbol to
7810                              this location in the opd section.  It is
7811                              necessary to update the value here rather
7812                              than using an array of adjustments as we do
7813                              for local symbols, because various places
7814                              in the generic ELF code use the value
7815                              stored in u.def.value.  */
7816                           fdh->elf.root.u.def.value = wptr - new_contents;
7817                           fdh->adjust_done = 1;
7818                         }
7819
7820                       /* Local syms are a bit tricky.  We could
7821                          tweak them as they can be cached, but
7822                          we'd need to look through the local syms
7823                          for the function descriptor sym which we
7824                          don't have at the moment.  So keep an
7825                          array of adjustments.  */
7826                       opd->adjust[rel->r_offset / 8]
7827                         = (wptr - new_contents) - (rptr - sec->contents);
7828
7829                       if (wptr != rptr)
7830                         memcpy (wptr, rptr, opd_ent_size);
7831                       wptr += opd_ent_size;
7832                       if (add_aux_fields && opd_ent_size == 16)
7833                         {
7834                           memset (wptr, '\0', 8);
7835                           wptr += 8;
7836                         }
7837                     }
7838                   rptr += opd_ent_size;
7839                   offset += opd_ent_size;
7840                 }
7841
7842               if (skip)
7843                 {
7844                   if (!NO_OPD_RELOCS
7845                       && !info->relocatable
7846                       && !dec_dynrel_count (rel->r_info, sec, info,
7847                                             NULL, h, sym))
7848                     goto error_ret;
7849                 }
7850               else
7851                 {
7852                   /* We need to adjust any reloc offsets to point to the
7853                      new opd entries.  While we're at it, we may as well
7854                      remove redundant relocs.  */
7855                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7856                   if (write_rel != rel)
7857                     memcpy (write_rel, rel, sizeof (*rel));
7858                   ++write_rel;
7859                 }
7860             }
7861
7862           sec->size = wptr - new_contents;
7863           sec->reloc_count = write_rel - relstart;
7864           if (add_aux_fields)
7865             {
7866               free (sec->contents);
7867               sec->contents = new_contents;
7868             }
7869
7870           /* Fudge the header size too, as this is used later in
7871              elf_bfd_final_link if we are emitting relocs.  */
7872           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7873           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7874           some_edited = TRUE;
7875         }
7876       else if (elf_section_data (sec)->relocs != relstart)
7877         free (relstart);
7878
7879       if (local_syms != NULL
7880           && symtab_hdr->contents != (unsigned char *) local_syms)
7881         {
7882           if (!info->keep_memory)
7883             free (local_syms);
7884           else
7885             symtab_hdr->contents = (unsigned char *) local_syms;
7886         }
7887     }
7888
7889   if (some_edited)
7890     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7891
7892   /* If we are doing a final link and the last .opd entry is just 16 byte
7893      long, add a 8 byte padding after it.  */
7894   if (need_pad != NULL && !info->relocatable)
7895     {
7896       bfd_byte *p;
7897
7898       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7899         {
7900           BFD_ASSERT (need_pad->size > 0);
7901
7902           p = bfd_malloc (need_pad->size + 8);
7903           if (p == NULL)
7904             return FALSE;
7905
7906           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7907                                           p, 0, need_pad->size))
7908             return FALSE;
7909
7910           need_pad->contents = p;
7911           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7912         }
7913       else
7914         {
7915           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7916           if (p == NULL)
7917             return FALSE;
7918
7919           need_pad->contents = p;
7920         }
7921
7922       memset (need_pad->contents + need_pad->size, 0, 8);
7923       need_pad->size += 8;
7924     }
7925
7926   return TRUE;
7927 }
7928
7929 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7930
7931 asection *
7932 ppc64_elf_tls_setup (struct bfd_link_info *info)
7933 {
7934   struct ppc_link_hash_table *htab;
7935
7936   htab = ppc_hash_table (info);
7937   if (htab == NULL)
7938     return NULL;
7939
7940   if (abiversion (info->output_bfd) == 1)
7941     htab->opd_abi = 1;
7942
7943   if (htab->params->no_multi_toc)
7944     htab->do_multi_toc = 0;
7945   else if (!htab->do_multi_toc)
7946     htab->params->no_multi_toc = 1;
7947
7948   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7949                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7950                                               FALSE, FALSE, TRUE));
7951   /* Move dynamic linking info to the function descriptor sym.  */
7952   if (htab->tls_get_addr != NULL)
7953     func_desc_adjust (&htab->tls_get_addr->elf, info);
7954   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7955                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7956                                                  FALSE, FALSE, TRUE));
7957   if (!htab->params->no_tls_get_addr_opt)
7958     {
7959       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7960
7961       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7962                                   FALSE, FALSE, TRUE);
7963       if (opt != NULL)
7964         func_desc_adjust (opt, info);
7965       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7966                                      FALSE, FALSE, TRUE);
7967       if (opt_fd != NULL
7968           && (opt_fd->root.type == bfd_link_hash_defined
7969               || opt_fd->root.type == bfd_link_hash_defweak))
7970         {
7971           /* If glibc supports an optimized __tls_get_addr call stub,
7972              signalled by the presence of __tls_get_addr_opt, and we'll
7973              be calling __tls_get_addr via a plt call stub, then
7974              make __tls_get_addr point to __tls_get_addr_opt.  */
7975           tga_fd = &htab->tls_get_addr_fd->elf;
7976           if (htab->elf.dynamic_sections_created
7977               && tga_fd != NULL
7978               && (tga_fd->type == STT_FUNC
7979                   || tga_fd->needs_plt)
7980               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7981                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7982                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7983             {
7984               struct plt_entry *ent;
7985
7986               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7987                 if (ent->plt.refcount > 0)
7988                   break;
7989               if (ent != NULL)
7990                 {
7991                   tga_fd->root.type = bfd_link_hash_indirect;
7992                   tga_fd->root.u.i.link = &opt_fd->root;
7993                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7994                   if (opt_fd->dynindx != -1)
7995                     {
7996                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7997                       opt_fd->dynindx = -1;
7998                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7999                                               opt_fd->dynstr_index);
8000                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8001                         return NULL;
8002                     }
8003                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8004                   tga = &htab->tls_get_addr->elf;
8005                   if (opt != NULL && tga != NULL)
8006                     {
8007                       tga->root.type = bfd_link_hash_indirect;
8008                       tga->root.u.i.link = &opt->root;
8009                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8010                       _bfd_elf_link_hash_hide_symbol (info, opt,
8011                                                       tga->forced_local);
8012                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8013                     }
8014                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8015                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8016                   if (htab->tls_get_addr != NULL)
8017                     {
8018                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8019                       htab->tls_get_addr->is_func = 1;
8020                     }
8021                 }
8022             }
8023         }
8024       else
8025         htab->params->no_tls_get_addr_opt = TRUE;
8026     }
8027   return _bfd_elf_tls_setup (info->output_bfd, info);
8028 }
8029
8030 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8031    HASH1 or HASH2.  */
8032
8033 static bfd_boolean
8034 branch_reloc_hash_match (const bfd *ibfd,
8035                          const Elf_Internal_Rela *rel,
8036                          const struct ppc_link_hash_entry *hash1,
8037                          const struct ppc_link_hash_entry *hash2)
8038 {
8039   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8040   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8041   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8042
8043   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8044     {
8045       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8046       struct elf_link_hash_entry *h;
8047
8048       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8049       h = elf_follow_link (h);
8050       if (h == &hash1->elf || h == &hash2->elf)
8051         return TRUE;
8052     }
8053   return FALSE;
8054 }
8055
8056 /* Run through all the TLS relocs looking for optimization
8057    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8058    a preliminary section layout so that we know the TLS segment
8059    offsets.  We can't optimize earlier because some optimizations need
8060    to know the tp offset, and we need to optimize before allocating
8061    dynamic relocations.  */
8062
8063 bfd_boolean
8064 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8065 {
8066   bfd *ibfd;
8067   asection *sec;
8068   struct ppc_link_hash_table *htab;
8069   unsigned char *toc_ref;
8070   int pass;
8071
8072   if (info->relocatable || !info->executable)
8073     return TRUE;
8074
8075   htab = ppc_hash_table (info);
8076   if (htab == NULL)
8077     return FALSE;
8078
8079   /* Make two passes over the relocs.  On the first pass, mark toc
8080      entries involved with tls relocs, and check that tls relocs
8081      involved in setting up a tls_get_addr call are indeed followed by
8082      such a call.  If they are not, we can't do any tls optimization.
8083      On the second pass twiddle tls_mask flags to notify
8084      relocate_section that optimization can be done, and adjust got
8085      and plt refcounts.  */
8086   toc_ref = NULL;
8087   for (pass = 0; pass < 2; ++pass)
8088     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8089       {
8090         Elf_Internal_Sym *locsyms = NULL;
8091         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8092
8093         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8094           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8095             {
8096               Elf_Internal_Rela *relstart, *rel, *relend;
8097               bfd_boolean found_tls_get_addr_arg = 0;
8098
8099               /* Read the relocations.  */
8100               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8101                                                     info->keep_memory);
8102               if (relstart == NULL)
8103                 {
8104                   free (toc_ref);
8105                   return FALSE;
8106                 }
8107
8108               relend = relstart + sec->reloc_count;
8109               for (rel = relstart; rel < relend; rel++)
8110                 {
8111                   enum elf_ppc64_reloc_type r_type;
8112                   unsigned long r_symndx;
8113                   struct elf_link_hash_entry *h;
8114                   Elf_Internal_Sym *sym;
8115                   asection *sym_sec;
8116                   unsigned char *tls_mask;
8117                   unsigned char tls_set, tls_clear, tls_type = 0;
8118                   bfd_vma value;
8119                   bfd_boolean ok_tprel, is_local;
8120                   long toc_ref_index = 0;
8121                   int expecting_tls_get_addr = 0;
8122                   bfd_boolean ret = FALSE;
8123
8124                   r_symndx = ELF64_R_SYM (rel->r_info);
8125                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8126                                   r_symndx, ibfd))
8127                     {
8128                     err_free_rel:
8129                       if (elf_section_data (sec)->relocs != relstart)
8130                         free (relstart);
8131                       if (toc_ref != NULL)
8132                         free (toc_ref);
8133                       if (locsyms != NULL
8134                           && (elf_symtab_hdr (ibfd).contents
8135                               != (unsigned char *) locsyms))
8136                         free (locsyms);
8137                       return ret;
8138                     }
8139
8140                   if (h != NULL)
8141                     {
8142                       if (h->root.type == bfd_link_hash_defined
8143                           || h->root.type == bfd_link_hash_defweak)
8144                         value = h->root.u.def.value;
8145                       else if (h->root.type == bfd_link_hash_undefweak)
8146                         value = 0;
8147                       else
8148                         {
8149                           found_tls_get_addr_arg = 0;
8150                           continue;
8151                         }
8152                     }
8153                   else
8154                     /* Symbols referenced by TLS relocs must be of type
8155                        STT_TLS.  So no need for .opd local sym adjust.  */
8156                     value = sym->st_value;
8157
8158                   ok_tprel = FALSE;
8159                   is_local = FALSE;
8160                   if (h == NULL
8161                       || !h->def_dynamic)
8162                     {
8163                       is_local = TRUE;
8164                       if (h != NULL
8165                           && h->root.type == bfd_link_hash_undefweak)
8166                         ok_tprel = TRUE;
8167                       else
8168                         {
8169                           value += sym_sec->output_offset;
8170                           value += sym_sec->output_section->vma;
8171                           value -= htab->elf.tls_sec->vma;
8172                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8173                                       < (bfd_vma) 1 << 32);
8174                         }
8175                     }
8176
8177                   r_type = ELF64_R_TYPE (rel->r_info);
8178                   /* If this section has old-style __tls_get_addr calls
8179                      without marker relocs, then check that each
8180                      __tls_get_addr call reloc is preceded by a reloc
8181                      that conceivably belongs to the __tls_get_addr arg
8182                      setup insn.  If we don't find matching arg setup
8183                      relocs, don't do any tls optimization.  */
8184                   if (pass == 0
8185                       && sec->has_tls_get_addr_call
8186                       && h != NULL
8187                       && (h == &htab->tls_get_addr->elf
8188                           || h == &htab->tls_get_addr_fd->elf)
8189                       && !found_tls_get_addr_arg
8190                       && is_branch_reloc (r_type))
8191                     {
8192                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8193                                                 "TLS optimization disabled\n"),
8194                                               ibfd, sec, rel->r_offset);
8195                       ret = TRUE;
8196                       goto err_free_rel;
8197                     }
8198
8199                   found_tls_get_addr_arg = 0;
8200                   switch (r_type)
8201                     {
8202                     case R_PPC64_GOT_TLSLD16:
8203                     case R_PPC64_GOT_TLSLD16_LO:
8204                       expecting_tls_get_addr = 1;
8205                       found_tls_get_addr_arg = 1;
8206                       /* Fall thru */
8207
8208                     case R_PPC64_GOT_TLSLD16_HI:
8209                     case R_PPC64_GOT_TLSLD16_HA:
8210                       /* These relocs should never be against a symbol
8211                          defined in a shared lib.  Leave them alone if
8212                          that turns out to be the case.  */
8213                       if (!is_local)
8214                         continue;
8215
8216                       /* LD -> LE */
8217                       tls_set = 0;
8218                       tls_clear = TLS_LD;
8219                       tls_type = TLS_TLS | TLS_LD;
8220                       break;
8221
8222                     case R_PPC64_GOT_TLSGD16:
8223                     case R_PPC64_GOT_TLSGD16_LO:
8224                       expecting_tls_get_addr = 1;
8225                       found_tls_get_addr_arg = 1;
8226                       /* Fall thru */
8227
8228                     case R_PPC64_GOT_TLSGD16_HI:
8229                     case R_PPC64_GOT_TLSGD16_HA:
8230                       if (ok_tprel)
8231                         /* GD -> LE */
8232                         tls_set = 0;
8233                       else
8234                         /* GD -> IE */
8235                         tls_set = TLS_TLS | TLS_TPRELGD;
8236                       tls_clear = TLS_GD;
8237                       tls_type = TLS_TLS | TLS_GD;
8238                       break;
8239
8240                     case R_PPC64_GOT_TPREL16_DS:
8241                     case R_PPC64_GOT_TPREL16_LO_DS:
8242                     case R_PPC64_GOT_TPREL16_HI:
8243                     case R_PPC64_GOT_TPREL16_HA:
8244                       if (ok_tprel)
8245                         {
8246                           /* IE -> LE */
8247                           tls_set = 0;
8248                           tls_clear = TLS_TPREL;
8249                           tls_type = TLS_TLS | TLS_TPREL;
8250                           break;
8251                         }
8252                       continue;
8253
8254                     case R_PPC64_TLSGD:
8255                     case R_PPC64_TLSLD:
8256                       found_tls_get_addr_arg = 1;
8257                       /* Fall thru */
8258
8259                     case R_PPC64_TLS:
8260                     case R_PPC64_TOC16:
8261                     case R_PPC64_TOC16_LO:
8262                       if (sym_sec == NULL || sym_sec != toc)
8263                         continue;
8264
8265                       /* Mark this toc entry as referenced by a TLS
8266                          code sequence.  We can do that now in the
8267                          case of R_PPC64_TLS, and after checking for
8268                          tls_get_addr for the TOC16 relocs.  */
8269                       if (toc_ref == NULL)
8270                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8271                       if (toc_ref == NULL)
8272                         goto err_free_rel;
8273
8274                       if (h != NULL)
8275                         value = h->root.u.def.value;
8276                       else
8277                         value = sym->st_value;
8278                       value += rel->r_addend;
8279                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8280                       toc_ref_index = (value + toc->output_offset) / 8;
8281                       if (r_type == R_PPC64_TLS
8282                           || r_type == R_PPC64_TLSGD
8283                           || r_type == R_PPC64_TLSLD)
8284                         {
8285                           toc_ref[toc_ref_index] = 1;
8286                           continue;
8287                         }
8288
8289                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8290                         continue;
8291
8292                       tls_set = 0;
8293                       tls_clear = 0;
8294                       expecting_tls_get_addr = 2;
8295                       break;
8296
8297                     case R_PPC64_TPREL64:
8298                       if (pass == 0
8299                           || sec != toc
8300                           || toc_ref == NULL
8301                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8302                         continue;
8303                       if (ok_tprel)
8304                         {
8305                           /* IE -> LE */
8306                           tls_set = TLS_EXPLICIT;
8307                           tls_clear = TLS_TPREL;
8308                           break;
8309                         }
8310                       continue;
8311
8312                     case R_PPC64_DTPMOD64:
8313                       if (pass == 0
8314                           || sec != toc
8315                           || toc_ref == NULL
8316                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8317                         continue;
8318                       if (rel + 1 < relend
8319                           && (rel[1].r_info
8320                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8321                           && rel[1].r_offset == rel->r_offset + 8)
8322                         {
8323                           if (ok_tprel)
8324                             /* GD -> LE */
8325                             tls_set = TLS_EXPLICIT | TLS_GD;
8326                           else
8327                             /* GD -> IE */
8328                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8329                           tls_clear = TLS_GD;
8330                         }
8331                       else
8332                         {
8333                           if (!is_local)
8334                             continue;
8335
8336                           /* LD -> LE */
8337                           tls_set = TLS_EXPLICIT;
8338                           tls_clear = TLS_LD;
8339                         }
8340                       break;
8341
8342                     default:
8343                       continue;
8344                     }
8345
8346                   if (pass == 0)
8347                     {
8348                       if (!expecting_tls_get_addr
8349                           || !sec->has_tls_get_addr_call)
8350                         continue;
8351
8352                       if (rel + 1 < relend
8353                           && branch_reloc_hash_match (ibfd, rel + 1,
8354                                                       htab->tls_get_addr,
8355                                                       htab->tls_get_addr_fd))
8356                         {
8357                           if (expecting_tls_get_addr == 2)
8358                             {
8359                               /* Check for toc tls entries.  */
8360                               unsigned char *toc_tls;
8361                               int retval;
8362
8363                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8364                                                      &locsyms,
8365                                                      rel, ibfd);
8366                               if (retval == 0)
8367                                 goto err_free_rel;
8368                               if (toc_tls != NULL)
8369                                 {
8370                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8371                                     found_tls_get_addr_arg = 1;
8372                                   if (retval > 1)
8373                                     toc_ref[toc_ref_index] = 1;
8374                                 }
8375                             }
8376                           continue;
8377                         }
8378
8379                       if (expecting_tls_get_addr != 1)
8380                         continue;
8381
8382                       /* Uh oh, we didn't find the expected call.  We
8383                          could just mark this symbol to exclude it
8384                          from tls optimization but it's safer to skip
8385                          the entire optimization.  */
8386                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8387                                                 "TLS optimization disabled\n"),
8388                                               ibfd, sec, rel->r_offset);
8389                       ret = TRUE;
8390                       goto err_free_rel;
8391                     }
8392
8393                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8394                     {
8395                       struct plt_entry *ent;
8396                       for (ent = htab->tls_get_addr->elf.plt.plist;
8397                            ent != NULL;
8398                            ent = ent->next)
8399                         if (ent->addend == 0)
8400                           {
8401                             if (ent->plt.refcount > 0)
8402                               {
8403                                 ent->plt.refcount -= 1;
8404                                 expecting_tls_get_addr = 0;
8405                               }
8406                             break;
8407                           }
8408                     }
8409
8410                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8411                     {
8412                       struct plt_entry *ent;
8413                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8414                            ent != NULL;
8415                            ent = ent->next)
8416                         if (ent->addend == 0)
8417                           {
8418                             if (ent->plt.refcount > 0)
8419                               ent->plt.refcount -= 1;
8420                             break;
8421                           }
8422                     }
8423
8424                   if (tls_clear == 0)
8425                     continue;
8426
8427                   if ((tls_set & TLS_EXPLICIT) == 0)
8428                     {
8429                       struct got_entry *ent;
8430
8431                       /* Adjust got entry for this reloc.  */
8432                       if (h != NULL)
8433                         ent = h->got.glist;
8434                       else
8435                         ent = elf_local_got_ents (ibfd)[r_symndx];
8436
8437                       for (; ent != NULL; ent = ent->next)
8438                         if (ent->addend == rel->r_addend
8439                             && ent->owner == ibfd
8440                             && ent->tls_type == tls_type)
8441                           break;
8442                       if (ent == NULL)
8443                         abort ();
8444
8445                       if (tls_set == 0)
8446                         {
8447                           /* We managed to get rid of a got entry.  */
8448                           if (ent->got.refcount > 0)
8449                             ent->got.refcount -= 1;
8450                         }
8451                     }
8452                   else
8453                     {
8454                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8455                          we'll lose one or two dyn relocs.  */
8456                       if (!dec_dynrel_count (rel->r_info, sec, info,
8457                                              NULL, h, sym))
8458                         return FALSE;
8459
8460                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8461                         {
8462                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8463                                                  NULL, h, sym))
8464                             return FALSE;
8465                         }
8466                     }
8467
8468                   *tls_mask |= tls_set;
8469                   *tls_mask &= ~tls_clear;
8470                 }
8471
8472               if (elf_section_data (sec)->relocs != relstart)
8473                 free (relstart);
8474             }
8475
8476         if (locsyms != NULL
8477             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8478           {
8479             if (!info->keep_memory)
8480               free (locsyms);
8481             else
8482               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8483           }
8484       }
8485
8486   if (toc_ref != NULL)
8487     free (toc_ref);
8488   return TRUE;
8489 }
8490
8491 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8492    the values of any global symbols in a toc section that has been
8493    edited.  Globals in toc sections should be a rarity, so this function
8494    sets a flag if any are found in toc sections other than the one just
8495    edited, so that futher hash table traversals can be avoided.  */
8496
8497 struct adjust_toc_info
8498 {
8499   asection *toc;
8500   unsigned long *skip;
8501   bfd_boolean global_toc_syms;
8502 };
8503
8504 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8505
8506 static bfd_boolean
8507 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8508 {
8509   struct ppc_link_hash_entry *eh;
8510   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8511   unsigned long i;
8512
8513   if (h->root.type != bfd_link_hash_defined
8514       && h->root.type != bfd_link_hash_defweak)
8515     return TRUE;
8516
8517   eh = (struct ppc_link_hash_entry *) h;
8518   if (eh->adjust_done)
8519     return TRUE;
8520
8521   if (eh->elf.root.u.def.section == toc_inf->toc)
8522     {
8523       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8524         i = toc_inf->toc->rawsize >> 3;
8525       else
8526         i = eh->elf.root.u.def.value >> 3;
8527
8528       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8529         {
8530           (*_bfd_error_handler)
8531             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8532           do
8533             ++i;
8534           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8535           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8536         }
8537
8538       eh->elf.root.u.def.value -= toc_inf->skip[i];
8539       eh->adjust_done = 1;
8540     }
8541   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8542     toc_inf->global_toc_syms = TRUE;
8543
8544   return TRUE;
8545 }
8546
8547 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8548
8549 static bfd_boolean
8550 ok_lo_toc_insn (unsigned int insn)
8551 {
8552   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8553           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8554           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8555           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8556           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8557           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8558           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8559           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8560           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8561           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8562           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8563           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8564           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8565           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8566           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8567               && (insn & 3) != 1)
8568           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8569               && ((insn & 3) == 0 || (insn & 3) == 3))
8570           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8571 }
8572
8573 /* Examine all relocs referencing .toc sections in order to remove
8574    unused .toc entries.  */
8575
8576 bfd_boolean
8577 ppc64_elf_edit_toc (struct bfd_link_info *info)
8578 {
8579   bfd *ibfd;
8580   struct adjust_toc_info toc_inf;
8581   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8582
8583   htab->do_toc_opt = 1;
8584   toc_inf.global_toc_syms = TRUE;
8585   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8586     {
8587       asection *toc, *sec;
8588       Elf_Internal_Shdr *symtab_hdr;
8589       Elf_Internal_Sym *local_syms;
8590       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8591       unsigned long *skip, *drop;
8592       unsigned char *used;
8593       unsigned char *keep, last, some_unused;
8594
8595       if (!is_ppc64_elf (ibfd))
8596         continue;
8597
8598       toc = bfd_get_section_by_name (ibfd, ".toc");
8599       if (toc == NULL
8600           || toc->size == 0
8601           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8602           || discarded_section (toc))
8603         continue;
8604
8605       toc_relocs = NULL;
8606       local_syms = NULL;
8607       symtab_hdr = &elf_symtab_hdr (ibfd);
8608
8609       /* Look at sections dropped from the final link.  */
8610       skip = NULL;
8611       relstart = NULL;
8612       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8613         {
8614           if (sec->reloc_count == 0
8615               || !discarded_section (sec)
8616               || get_opd_info (sec)
8617               || (sec->flags & SEC_ALLOC) == 0
8618               || (sec->flags & SEC_DEBUGGING) != 0)
8619             continue;
8620
8621           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8622           if (relstart == NULL)
8623             goto error_ret;
8624
8625           /* Run through the relocs to see which toc entries might be
8626              unused.  */
8627           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8628             {
8629               enum elf_ppc64_reloc_type r_type;
8630               unsigned long r_symndx;
8631               asection *sym_sec;
8632               struct elf_link_hash_entry *h;
8633               Elf_Internal_Sym *sym;
8634               bfd_vma val;
8635
8636               r_type = ELF64_R_TYPE (rel->r_info);
8637               switch (r_type)
8638                 {
8639                 default:
8640                   continue;
8641
8642                 case R_PPC64_TOC16:
8643                 case R_PPC64_TOC16_LO:
8644                 case R_PPC64_TOC16_HI:
8645                 case R_PPC64_TOC16_HA:
8646                 case R_PPC64_TOC16_DS:
8647                 case R_PPC64_TOC16_LO_DS:
8648                   break;
8649                 }
8650
8651               r_symndx = ELF64_R_SYM (rel->r_info);
8652               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8653                               r_symndx, ibfd))
8654                 goto error_ret;
8655
8656               if (sym_sec != toc)
8657                 continue;
8658
8659               if (h != NULL)
8660                 val = h->root.u.def.value;
8661               else
8662                 val = sym->st_value;
8663               val += rel->r_addend;
8664
8665               if (val >= toc->size)
8666                 continue;
8667
8668               /* Anything in the toc ought to be aligned to 8 bytes.
8669                  If not, don't mark as unused.  */
8670               if (val & 7)
8671                 continue;
8672
8673               if (skip == NULL)
8674                 {
8675                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8676                   if (skip == NULL)
8677                     goto error_ret;
8678                 }
8679
8680               skip[val >> 3] = ref_from_discarded;
8681             }
8682
8683           if (elf_section_data (sec)->relocs != relstart)
8684             free (relstart);
8685         }
8686
8687       /* For largetoc loads of address constants, we can convert
8688          .  addis rx,2,addr@got@ha
8689          .  ld ry,addr@got@l(rx)
8690          to
8691          .  addis rx,2,addr@toc@ha
8692          .  addi ry,rx,addr@toc@l
8693          when addr is within 2G of the toc pointer.  This then means
8694          that the word storing "addr" in the toc is no longer needed.  */
8695
8696       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8697           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8698           && toc->reloc_count != 0)
8699         {
8700           /* Read toc relocs.  */
8701           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8702                                                   info->keep_memory);
8703           if (toc_relocs == NULL)
8704             goto error_ret;
8705
8706           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8707             {
8708               enum elf_ppc64_reloc_type r_type;
8709               unsigned long r_symndx;
8710               asection *sym_sec;
8711               struct elf_link_hash_entry *h;
8712               Elf_Internal_Sym *sym;
8713               bfd_vma val, addr;
8714
8715               r_type = ELF64_R_TYPE (rel->r_info);
8716               if (r_type != R_PPC64_ADDR64)
8717                 continue;
8718
8719               r_symndx = ELF64_R_SYM (rel->r_info);
8720               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8721                               r_symndx, ibfd))
8722                 goto error_ret;
8723
8724               if (sym_sec == NULL
8725                   || discarded_section (sym_sec))
8726                 continue;
8727
8728               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8729                 continue;
8730
8731               if (h != NULL)
8732                 {
8733                   if (h->type == STT_GNU_IFUNC)
8734                     continue;
8735                   val = h->root.u.def.value;
8736                 }
8737               else
8738                 {
8739                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8740                     continue;
8741                   val = sym->st_value;
8742                 }
8743               val += rel->r_addend;
8744               val += sym_sec->output_section->vma + sym_sec->output_offset;
8745
8746               /* We don't yet know the exact toc pointer value, but we
8747                  know it will be somewhere in the toc section.  Don't
8748                  optimize if the difference from any possible toc
8749                  pointer is outside [ff..f80008000, 7fff7fff].  */
8750               addr = toc->output_section->vma + TOC_BASE_OFF;
8751               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8752                 continue;
8753
8754               addr = toc->output_section->vma + toc->output_section->rawsize;
8755               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8756                 continue;
8757
8758               if (skip == NULL)
8759                 {
8760                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8761                   if (skip == NULL)
8762                     goto error_ret;
8763                 }
8764
8765               skip[rel->r_offset >> 3]
8766                 |= can_optimize | ((rel - toc_relocs) << 2);
8767             }
8768         }
8769
8770       if (skip == NULL)
8771         continue;
8772
8773       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8774       if (used == NULL)
8775         {
8776         error_ret:
8777           if (local_syms != NULL
8778               && symtab_hdr->contents != (unsigned char *) local_syms)
8779             free (local_syms);
8780           if (sec != NULL
8781               && relstart != NULL
8782               && elf_section_data (sec)->relocs != relstart)
8783             free (relstart);
8784           if (toc_relocs != NULL
8785               && elf_section_data (toc)->relocs != toc_relocs)
8786             free (toc_relocs);
8787           if (skip != NULL)
8788             free (skip);
8789           return FALSE;
8790         }
8791
8792       /* Now check all kept sections that might reference the toc.
8793          Check the toc itself last.  */
8794       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8795                   : ibfd->sections);
8796            sec != NULL;
8797            sec = (sec == toc ? NULL
8798                   : sec->next == NULL ? toc
8799                   : sec->next == toc && toc->next ? toc->next
8800                   : sec->next))
8801         {
8802           int repeat;
8803
8804           if (sec->reloc_count == 0
8805               || discarded_section (sec)
8806               || get_opd_info (sec)
8807               || (sec->flags & SEC_ALLOC) == 0
8808               || (sec->flags & SEC_DEBUGGING) != 0)
8809             continue;
8810
8811           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8812                                                 info->keep_memory);
8813           if (relstart == NULL)
8814             {
8815               free (used);
8816               goto error_ret;
8817             }
8818
8819           /* Mark toc entries referenced as used.  */
8820           do
8821             {
8822               repeat = 0;
8823               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8824                 {
8825                   enum elf_ppc64_reloc_type r_type;
8826                   unsigned long r_symndx;
8827                   asection *sym_sec;
8828                   struct elf_link_hash_entry *h;
8829                   Elf_Internal_Sym *sym;
8830                   bfd_vma val;
8831                   enum {no_check, check_lo, check_ha} insn_check;
8832
8833                   r_type = ELF64_R_TYPE (rel->r_info);
8834                   switch (r_type)
8835                     {
8836                     default:
8837                       insn_check = no_check;
8838                       break;
8839
8840                     case R_PPC64_GOT_TLSLD16_HA:
8841                     case R_PPC64_GOT_TLSGD16_HA:
8842                     case R_PPC64_GOT_TPREL16_HA:
8843                     case R_PPC64_GOT_DTPREL16_HA:
8844                     case R_PPC64_GOT16_HA:
8845                     case R_PPC64_TOC16_HA:
8846                       insn_check = check_ha;
8847                       break;
8848
8849                     case R_PPC64_GOT_TLSLD16_LO:
8850                     case R_PPC64_GOT_TLSGD16_LO:
8851                     case R_PPC64_GOT_TPREL16_LO_DS:
8852                     case R_PPC64_GOT_DTPREL16_LO_DS:
8853                     case R_PPC64_GOT16_LO:
8854                     case R_PPC64_GOT16_LO_DS:
8855                     case R_PPC64_TOC16_LO:
8856                     case R_PPC64_TOC16_LO_DS:
8857                       insn_check = check_lo;
8858                       break;
8859                     }
8860
8861                   if (insn_check != no_check)
8862                     {
8863                       bfd_vma off = rel->r_offset & ~3;
8864                       unsigned char buf[4];
8865                       unsigned int insn;
8866
8867                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8868                         {
8869                           free (used);
8870                           goto error_ret;
8871                         }
8872                       insn = bfd_get_32 (ibfd, buf);
8873                       if (insn_check == check_lo
8874                           ? !ok_lo_toc_insn (insn)
8875                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8876                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8877                         {
8878                           char str[12];
8879
8880                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8881                           sprintf (str, "%#08x", insn);
8882                           info->callbacks->einfo
8883                             (_("%P: %H: toc optimization is not supported for"
8884                                " %s instruction.\n"),
8885                              ibfd, sec, rel->r_offset & ~3, str);
8886                         }
8887                     }
8888
8889                   switch (r_type)
8890                     {
8891                     case R_PPC64_TOC16:
8892                     case R_PPC64_TOC16_LO:
8893                     case R_PPC64_TOC16_HI:
8894                     case R_PPC64_TOC16_HA:
8895                     case R_PPC64_TOC16_DS:
8896                     case R_PPC64_TOC16_LO_DS:
8897                       /* In case we're taking addresses of toc entries.  */
8898                     case R_PPC64_ADDR64:
8899                       break;
8900
8901                     default:
8902                       continue;
8903                     }
8904
8905                   r_symndx = ELF64_R_SYM (rel->r_info);
8906                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8907                                   r_symndx, ibfd))
8908                     {
8909                       free (used);
8910                       goto error_ret;
8911                     }
8912
8913                   if (sym_sec != toc)
8914                     continue;
8915
8916                   if (h != NULL)
8917                     val = h->root.u.def.value;
8918                   else
8919                     val = sym->st_value;
8920                   val += rel->r_addend;
8921
8922                   if (val >= toc->size)
8923                     continue;
8924
8925                   if ((skip[val >> 3] & can_optimize) != 0)
8926                     {
8927                       bfd_vma off;
8928                       unsigned char opc;
8929
8930                       switch (r_type)
8931                         {
8932                         case R_PPC64_TOC16_HA:
8933                           break;
8934
8935                         case R_PPC64_TOC16_LO_DS:
8936                           off = rel->r_offset;
8937                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8938                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8939                                                          off, 1))
8940                             {
8941                               free (used);
8942                               goto error_ret;
8943                             }
8944                           if ((opc & (0x3f << 2)) == (58u << 2))
8945                             break;
8946                           /* Fall thru */
8947
8948                         default:
8949                           /* Wrong sort of reloc, or not a ld.  We may
8950                              as well clear ref_from_discarded too.  */
8951                           skip[val >> 3] = 0;
8952                         }
8953                     }
8954
8955                   if (sec != toc)
8956                     used[val >> 3] = 1;
8957                   /* For the toc section, we only mark as used if this
8958                      entry itself isn't unused.  */
8959                   else if ((used[rel->r_offset >> 3]
8960                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8961                            && !used[val >> 3])
8962                     {
8963                       /* Do all the relocs again, to catch reference
8964                          chains.  */
8965                       repeat = 1;
8966                       used[val >> 3] = 1;
8967                     }
8968                 }
8969             }
8970           while (repeat);
8971
8972           if (elf_section_data (sec)->relocs != relstart)
8973             free (relstart);
8974         }
8975
8976       /* Merge the used and skip arrays.  Assume that TOC
8977          doublewords not appearing as either used or unused belong
8978          to to an entry more than one doubleword in size.  */
8979       for (drop = skip, keep = used, last = 0, some_unused = 0;
8980            drop < skip + (toc->size + 7) / 8;
8981            ++drop, ++keep)
8982         {
8983           if (*keep)
8984             {
8985               *drop &= ~ref_from_discarded;
8986               if ((*drop & can_optimize) != 0)
8987                 some_unused = 1;
8988               last = 0;
8989             }
8990           else if ((*drop & ref_from_discarded) != 0)
8991             {
8992               some_unused = 1;
8993               last = ref_from_discarded;
8994             }
8995           else
8996             *drop = last;
8997         }
8998
8999       free (used);
9000
9001       if (some_unused)
9002         {
9003           bfd_byte *contents, *src;
9004           unsigned long off;
9005           Elf_Internal_Sym *sym;
9006           bfd_boolean local_toc_syms = FALSE;
9007
9008           /* Shuffle the toc contents, and at the same time convert the
9009              skip array from booleans into offsets.  */
9010           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9011             goto error_ret;
9012
9013           elf_section_data (toc)->this_hdr.contents = contents;
9014
9015           for (src = contents, off = 0, drop = skip;
9016                src < contents + toc->size;
9017                src += 8, ++drop)
9018             {
9019               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9020                 off += 8;
9021               else if (off != 0)
9022                 {
9023                   *drop = off;
9024                   memcpy (src - off, src, 8);
9025                 }
9026             }
9027           *drop = off;
9028           toc->rawsize = toc->size;
9029           toc->size = src - contents - off;
9030
9031           /* Adjust addends for relocs against the toc section sym,
9032              and optimize any accesses we can.  */
9033           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9034             {
9035               if (sec->reloc_count == 0
9036                   || discarded_section (sec))
9037                 continue;
9038
9039               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9040                                                     info->keep_memory);
9041               if (relstart == NULL)
9042                 goto error_ret;
9043
9044               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9045                 {
9046                   enum elf_ppc64_reloc_type r_type;
9047                   unsigned long r_symndx;
9048                   asection *sym_sec;
9049                   struct elf_link_hash_entry *h;
9050                   bfd_vma val;
9051
9052                   r_type = ELF64_R_TYPE (rel->r_info);
9053                   switch (r_type)
9054                     {
9055                     default:
9056                       continue;
9057
9058                     case R_PPC64_TOC16:
9059                     case R_PPC64_TOC16_LO:
9060                     case R_PPC64_TOC16_HI:
9061                     case R_PPC64_TOC16_HA:
9062                     case R_PPC64_TOC16_DS:
9063                     case R_PPC64_TOC16_LO_DS:
9064                     case R_PPC64_ADDR64:
9065                       break;
9066                     }
9067
9068                   r_symndx = ELF64_R_SYM (rel->r_info);
9069                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9070                                   r_symndx, ibfd))
9071                     goto error_ret;
9072
9073                   if (sym_sec != toc)
9074                     continue;
9075
9076                   if (h != NULL)
9077                     val = h->root.u.def.value;
9078                   else
9079                     {
9080                       val = sym->st_value;
9081                       if (val != 0)
9082                         local_toc_syms = TRUE;
9083                     }
9084
9085                   val += rel->r_addend;
9086
9087                   if (val > toc->rawsize)
9088                     val = toc->rawsize;
9089                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9090                     continue;
9091                   else if ((skip[val >> 3] & can_optimize) != 0)
9092                     {
9093                       Elf_Internal_Rela *tocrel
9094                         = toc_relocs + (skip[val >> 3] >> 2);
9095                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9096
9097                       switch (r_type)
9098                         {
9099                         case R_PPC64_TOC16_HA:
9100                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9101                           break;
9102
9103                         case R_PPC64_TOC16_LO_DS:
9104                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9105                           break;
9106
9107                         default:
9108                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9109                             ppc_howto_init ();
9110                           info->callbacks->einfo
9111                             (_("%P: %H: %s references "
9112                                "optimized away TOC entry\n"),
9113                              ibfd, sec, rel->r_offset,
9114                              ppc64_elf_howto_table[r_type]->name);
9115                           bfd_set_error (bfd_error_bad_value);
9116                           goto error_ret;
9117                         }
9118                       rel->r_addend = tocrel->r_addend;
9119                       elf_section_data (sec)->relocs = relstart;
9120                       continue;
9121                     }
9122
9123                   if (h != NULL || sym->st_value != 0)
9124                     continue;
9125
9126                   rel->r_addend -= skip[val >> 3];
9127                   elf_section_data (sec)->relocs = relstart;
9128                 }
9129
9130               if (elf_section_data (sec)->relocs != relstart)
9131                 free (relstart);
9132             }
9133
9134           /* We shouldn't have local or global symbols defined in the TOC,
9135              but handle them anyway.  */
9136           if (local_syms != NULL)
9137             for (sym = local_syms;
9138                  sym < local_syms + symtab_hdr->sh_info;
9139                  ++sym)
9140               if (sym->st_value != 0
9141                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9142                 {
9143                   unsigned long i;
9144
9145                   if (sym->st_value > toc->rawsize)
9146                     i = toc->rawsize >> 3;
9147                   else
9148                     i = sym->st_value >> 3;
9149
9150                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9151                     {
9152                       if (local_toc_syms)
9153                         (*_bfd_error_handler)
9154                           (_("%s defined on removed toc entry"),
9155                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9156                       do
9157                         ++i;
9158                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9159                       sym->st_value = (bfd_vma) i << 3;
9160                     }
9161
9162                   sym->st_value -= skip[i];
9163                   symtab_hdr->contents = (unsigned char *) local_syms;
9164                 }
9165
9166           /* Adjust any global syms defined in this toc input section.  */
9167           if (toc_inf.global_toc_syms)
9168             {
9169               toc_inf.toc = toc;
9170               toc_inf.skip = skip;
9171               toc_inf.global_toc_syms = FALSE;
9172               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9173                                       &toc_inf);
9174             }
9175
9176           if (toc->reloc_count != 0)
9177             {
9178               Elf_Internal_Shdr *rel_hdr;
9179               Elf_Internal_Rela *wrel;
9180               bfd_size_type sz;
9181
9182               /* Remove unused toc relocs, and adjust those we keep.  */
9183               if (toc_relocs == NULL)
9184                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9185                                                         info->keep_memory);
9186               if (toc_relocs == NULL)
9187                 goto error_ret;
9188
9189               wrel = toc_relocs;
9190               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9191                 if ((skip[rel->r_offset >> 3]
9192                      & (ref_from_discarded | can_optimize)) == 0)
9193                   {
9194                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9195                     wrel->r_info = rel->r_info;
9196                     wrel->r_addend = rel->r_addend;
9197                     ++wrel;
9198                   }
9199                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9200                                             &local_syms, NULL, NULL))
9201                   goto error_ret;
9202
9203               elf_section_data (toc)->relocs = toc_relocs;
9204               toc->reloc_count = wrel - toc_relocs;
9205               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9206               sz = rel_hdr->sh_entsize;
9207               rel_hdr->sh_size = toc->reloc_count * sz;
9208             }
9209         }
9210       else if (toc_relocs != NULL
9211                && elf_section_data (toc)->relocs != toc_relocs)
9212         free (toc_relocs);
9213
9214       if (local_syms != NULL
9215           && symtab_hdr->contents != (unsigned char *) local_syms)
9216         {
9217           if (!info->keep_memory)
9218             free (local_syms);
9219           else
9220             symtab_hdr->contents = (unsigned char *) local_syms;
9221         }
9222       free (skip);
9223     }
9224
9225   return TRUE;
9226 }
9227
9228 /* Return true iff input section I references the TOC using
9229    instructions limited to +/-32k offsets.  */
9230
9231 bfd_boolean
9232 ppc64_elf_has_small_toc_reloc (asection *i)
9233 {
9234   return (is_ppc64_elf (i->owner)
9235           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9236 }
9237
9238 /* Allocate space for one GOT entry.  */
9239
9240 static void
9241 allocate_got (struct elf_link_hash_entry *h,
9242               struct bfd_link_info *info,
9243               struct got_entry *gent)
9244 {
9245   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9246   bfd_boolean dyn;
9247   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9248   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9249                  ? 16 : 8);
9250   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9251                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9252   asection *got = ppc64_elf_tdata (gent->owner)->got;
9253
9254   gent->got.offset = got->size;
9255   got->size += entsize;
9256
9257   dyn = htab->elf.dynamic_sections_created;
9258   if (h->type == STT_GNU_IFUNC)
9259     {
9260       htab->elf.irelplt->size += rentsize;
9261       htab->got_reli_size += rentsize;
9262     }
9263   else if ((info->shared
9264             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9265            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9266                || h->root.type != bfd_link_hash_undefweak))
9267     {
9268       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9269       relgot->size += rentsize;
9270     }
9271 }
9272
9273 /* This function merges got entries in the same toc group.  */
9274
9275 static void
9276 merge_got_entries (struct got_entry **pent)
9277 {
9278   struct got_entry *ent, *ent2;
9279
9280   for (ent = *pent; ent != NULL; ent = ent->next)
9281     if (!ent->is_indirect)
9282       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9283         if (!ent2->is_indirect
9284             && ent2->addend == ent->addend
9285             && ent2->tls_type == ent->tls_type
9286             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9287           {
9288             ent2->is_indirect = TRUE;
9289             ent2->got.ent = ent;
9290           }
9291 }
9292
9293 /* Allocate space in .plt, .got and associated reloc sections for
9294    dynamic relocs.  */
9295
9296 static bfd_boolean
9297 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9298 {
9299   struct bfd_link_info *info;
9300   struct ppc_link_hash_table *htab;
9301   asection *s;
9302   struct ppc_link_hash_entry *eh;
9303   struct elf_dyn_relocs *p;
9304   struct got_entry **pgent, *gent;
9305
9306   if (h->root.type == bfd_link_hash_indirect)
9307     return TRUE;
9308
9309   info = (struct bfd_link_info *) inf;
9310   htab = ppc_hash_table (info);
9311   if (htab == NULL)
9312     return FALSE;
9313
9314   if ((htab->elf.dynamic_sections_created
9315        && h->dynindx != -1
9316        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9317       || h->type == STT_GNU_IFUNC)
9318     {
9319       struct plt_entry *pent;
9320       bfd_boolean doneone = FALSE;
9321       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9322         if (pent->plt.refcount > 0)
9323           {
9324             if (!htab->elf.dynamic_sections_created
9325                 || h->dynindx == -1)
9326               {
9327                 s = htab->elf.iplt;
9328                 pent->plt.offset = s->size;
9329                 s->size += PLT_ENTRY_SIZE (htab);
9330                 s = htab->elf.irelplt;
9331               }
9332             else
9333               {
9334                 /* If this is the first .plt entry, make room for the special
9335                    first entry.  */
9336                 s = htab->elf.splt;
9337                 if (s->size == 0)
9338                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9339
9340                 pent->plt.offset = s->size;
9341
9342                 /* Make room for this entry.  */
9343                 s->size += PLT_ENTRY_SIZE (htab);
9344
9345                 /* Make room for the .glink code.  */
9346                 s = htab->glink;
9347                 if (s->size == 0)
9348                   s->size += GLINK_CALL_STUB_SIZE;
9349                 if (htab->opd_abi)
9350                   {
9351                     /* We need bigger stubs past index 32767.  */
9352                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9353                       s->size += 4;
9354                     s->size += 2*4;
9355                   }
9356                 else
9357                   s->size += 4;
9358
9359                 /* We also need to make an entry in the .rela.plt section.  */
9360                 s = htab->elf.srelplt;
9361               }
9362             s->size += sizeof (Elf64_External_Rela);
9363             doneone = TRUE;
9364           }
9365         else
9366           pent->plt.offset = (bfd_vma) -1;
9367       if (!doneone)
9368         {
9369           h->plt.plist = NULL;
9370           h->needs_plt = 0;
9371         }
9372     }
9373   else
9374     {
9375       h->plt.plist = NULL;
9376       h->needs_plt = 0;
9377     }
9378
9379   eh = (struct ppc_link_hash_entry *) h;
9380   /* Run through the TLS GD got entries first if we're changing them
9381      to TPREL.  */
9382   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9383     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9384       if (gent->got.refcount > 0
9385           && (gent->tls_type & TLS_GD) != 0)
9386         {
9387           /* This was a GD entry that has been converted to TPREL.  If
9388              there happens to be a TPREL entry we can use that one.  */
9389           struct got_entry *ent;
9390           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9391             if (ent->got.refcount > 0
9392                 && (ent->tls_type & TLS_TPREL) != 0
9393                 && ent->addend == gent->addend
9394                 && ent->owner == gent->owner)
9395               {
9396                 gent->got.refcount = 0;
9397                 break;
9398               }
9399
9400           /* If not, then we'll be using our own TPREL entry.  */
9401           if (gent->got.refcount != 0)
9402             gent->tls_type = TLS_TLS | TLS_TPREL;
9403         }
9404
9405   /* Remove any list entry that won't generate a word in the GOT before
9406      we call merge_got_entries.  Otherwise we risk merging to empty
9407      entries.  */
9408   pgent = &h->got.glist;
9409   while ((gent = *pgent) != NULL)
9410     if (gent->got.refcount > 0)
9411       {
9412         if ((gent->tls_type & TLS_LD) != 0
9413             && !h->def_dynamic)
9414           {
9415             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9416             *pgent = gent->next;
9417           }
9418         else
9419           pgent = &gent->next;
9420       }
9421     else
9422       *pgent = gent->next;
9423
9424   if (!htab->do_multi_toc)
9425     merge_got_entries (&h->got.glist);
9426
9427   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9428     if (!gent->is_indirect)
9429       {
9430         /* Make sure this symbol is output as a dynamic symbol.
9431            Undefined weak syms won't yet be marked as dynamic,
9432            nor will all TLS symbols.  */
9433         if (h->dynindx == -1
9434             && !h->forced_local
9435             && h->type != STT_GNU_IFUNC
9436             && htab->elf.dynamic_sections_created)
9437           {
9438             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9439               return FALSE;
9440           }
9441
9442         if (!is_ppc64_elf (gent->owner))
9443           abort ();
9444
9445         allocate_got (h, info, gent);
9446       }
9447
9448   if (eh->dyn_relocs == NULL
9449       || (!htab->elf.dynamic_sections_created
9450           && h->type != STT_GNU_IFUNC))
9451     return TRUE;
9452
9453   /* In the shared -Bsymbolic case, discard space allocated for
9454      dynamic pc-relative relocs against symbols which turn out to be
9455      defined in regular objects.  For the normal shared case, discard
9456      space for relocs that have become local due to symbol visibility
9457      changes.  */
9458
9459   if (info->shared)
9460     {
9461       /* Relocs that use pc_count are those that appear on a call insn,
9462          or certain REL relocs (see must_be_dyn_reloc) that can be
9463          generated via assembly.  We want calls to protected symbols to
9464          resolve directly to the function rather than going via the plt.
9465          If people want function pointer comparisons to work as expected
9466          then they should avoid writing weird assembly.  */
9467       if (SYMBOL_CALLS_LOCAL (info, h))
9468         {
9469           struct elf_dyn_relocs **pp;
9470
9471           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9472             {
9473               p->count -= p->pc_count;
9474               p->pc_count = 0;
9475               if (p->count == 0)
9476                 *pp = p->next;
9477               else
9478                 pp = &p->next;
9479             }
9480         }
9481
9482       /* Also discard relocs on undefined weak syms with non-default
9483          visibility.  */
9484       if (eh->dyn_relocs != NULL
9485           && h->root.type == bfd_link_hash_undefweak)
9486         {
9487           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9488             eh->dyn_relocs = NULL;
9489
9490           /* Make sure this symbol is output as a dynamic symbol.
9491              Undefined weak syms won't yet be marked as dynamic.  */
9492           else if (h->dynindx == -1
9493                    && !h->forced_local)
9494             {
9495               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9496                 return FALSE;
9497             }
9498         }
9499     }
9500   else if (h->type == STT_GNU_IFUNC)
9501     {
9502       if (!h->non_got_ref)
9503         eh->dyn_relocs = NULL;
9504     }
9505   else if (ELIMINATE_COPY_RELOCS)
9506     {
9507       /* For the non-shared case, discard space for relocs against
9508          symbols which turn out to need copy relocs or are not
9509          dynamic.  */
9510
9511       if (!h->non_got_ref
9512           && !h->def_regular)
9513         {
9514           /* Make sure this symbol is output as a dynamic symbol.
9515              Undefined weak syms won't yet be marked as dynamic.  */
9516           if (h->dynindx == -1
9517               && !h->forced_local)
9518             {
9519               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9520                 return FALSE;
9521             }
9522
9523           /* If that succeeded, we know we'll be keeping all the
9524              relocs.  */
9525           if (h->dynindx != -1)
9526             goto keep;
9527         }
9528
9529       eh->dyn_relocs = NULL;
9530
9531     keep: ;
9532     }
9533
9534   /* Finally, allocate space.  */
9535   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9536     {
9537       asection *sreloc = elf_section_data (p->sec)->sreloc;
9538       if (eh->elf.type == STT_GNU_IFUNC)
9539         sreloc = htab->elf.irelplt;
9540       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9541     }
9542
9543   return TRUE;
9544 }
9545
9546 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9547    to set up space for global entry stubs.  These are put in glink,
9548    after the branch table.  */
9549
9550 static bfd_boolean
9551 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9552 {
9553   struct bfd_link_info *info;
9554   struct ppc_link_hash_table *htab;
9555   struct plt_entry *pent;
9556   asection *s;
9557
9558   if (h->root.type == bfd_link_hash_indirect)
9559     return TRUE;
9560
9561   if (!h->pointer_equality_needed)
9562     return TRUE;
9563
9564   if (h->def_regular)
9565     return TRUE;
9566
9567   info = inf;
9568   htab = ppc_hash_table (info);
9569   if (htab == NULL)
9570     return FALSE;
9571
9572   s = htab->glink;
9573   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9574     if (pent->plt.offset != (bfd_vma) -1
9575         && pent->addend == 0)
9576       {
9577         /* For ELFv2, if this symbol is not defined in a regular file
9578            and we are not generating a shared library or pie, then we
9579            need to define the symbol in the executable on a call stub.
9580            This is to avoid text relocations.  */
9581         s->size = (s->size + 15) & -16;
9582         h->root.u.def.section = s;
9583         h->root.u.def.value = s->size;
9584         s->size += 16;
9585         break;
9586       }
9587   return TRUE;
9588 }
9589
9590 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9591    read-only sections.  */
9592
9593 static bfd_boolean
9594 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9595 {
9596   if (h->root.type == bfd_link_hash_indirect)
9597     return TRUE;
9598
9599   if (readonly_dynrelocs (h))
9600     {
9601       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9602
9603       /* Not an error, just cut short the traversal.  */
9604       return FALSE;
9605     }
9606   return TRUE;
9607 }
9608
9609 /* Set the sizes of the dynamic sections.  */
9610
9611 static bfd_boolean
9612 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9613                                  struct bfd_link_info *info)
9614 {
9615   struct ppc_link_hash_table *htab;
9616   bfd *dynobj;
9617   asection *s;
9618   bfd_boolean relocs;
9619   bfd *ibfd;
9620   struct got_entry *first_tlsld;
9621
9622   htab = ppc_hash_table (info);
9623   if (htab == NULL)
9624     return FALSE;
9625
9626   dynobj = htab->elf.dynobj;
9627   if (dynobj == NULL)
9628     abort ();
9629
9630   if (htab->elf.dynamic_sections_created)
9631     {
9632       /* Set the contents of the .interp section to the interpreter.  */
9633       if (info->executable)
9634         {
9635           s = bfd_get_linker_section (dynobj, ".interp");
9636           if (s == NULL)
9637             abort ();
9638           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9639           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9640         }
9641     }
9642
9643   /* Set up .got offsets for local syms, and space for local dynamic
9644      relocs.  */
9645   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9646     {
9647       struct got_entry **lgot_ents;
9648       struct got_entry **end_lgot_ents;
9649       struct plt_entry **local_plt;
9650       struct plt_entry **end_local_plt;
9651       unsigned char *lgot_masks;
9652       bfd_size_type locsymcount;
9653       Elf_Internal_Shdr *symtab_hdr;
9654
9655       if (!is_ppc64_elf (ibfd))
9656         continue;
9657
9658       for (s = ibfd->sections; s != NULL; s = s->next)
9659         {
9660           struct ppc_dyn_relocs *p;
9661
9662           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9663             {
9664               if (!bfd_is_abs_section (p->sec)
9665                   && bfd_is_abs_section (p->sec->output_section))
9666                 {
9667                   /* Input section has been discarded, either because
9668                      it is a copy of a linkonce section or due to
9669                      linker script /DISCARD/, so we'll be discarding
9670                      the relocs too.  */
9671                 }
9672               else if (p->count != 0)
9673                 {
9674                   asection *srel = elf_section_data (p->sec)->sreloc;
9675                   if (p->ifunc)
9676                     srel = htab->elf.irelplt;
9677                   srel->size += p->count * sizeof (Elf64_External_Rela);
9678                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9679                     info->flags |= DF_TEXTREL;
9680                 }
9681             }
9682         }
9683
9684       lgot_ents = elf_local_got_ents (ibfd);
9685       if (!lgot_ents)
9686         continue;
9687
9688       symtab_hdr = &elf_symtab_hdr (ibfd);
9689       locsymcount = symtab_hdr->sh_info;
9690       end_lgot_ents = lgot_ents + locsymcount;
9691       local_plt = (struct plt_entry **) end_lgot_ents;
9692       end_local_plt = local_plt + locsymcount;
9693       lgot_masks = (unsigned char *) end_local_plt;
9694       s = ppc64_elf_tdata (ibfd)->got;
9695       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9696         {
9697           struct got_entry **pent, *ent;
9698
9699           pent = lgot_ents;
9700           while ((ent = *pent) != NULL)
9701             if (ent->got.refcount > 0)
9702               {
9703                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9704                   {
9705                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9706                     *pent = ent->next;
9707                   }
9708                 else
9709                   {
9710                     unsigned int ent_size = 8;
9711                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9712
9713                     ent->got.offset = s->size;
9714                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9715                       {
9716                         ent_size *= 2;
9717                         rel_size *= 2;
9718                       }
9719                     s->size += ent_size;
9720                     if ((*lgot_masks & PLT_IFUNC) != 0)
9721                       {
9722                         htab->elf.irelplt->size += rel_size;
9723                         htab->got_reli_size += rel_size;
9724                       }
9725                     else if (info->shared)
9726                       {
9727                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9728                         srel->size += rel_size;
9729                       }
9730                     pent = &ent->next;
9731                   }
9732               }
9733             else
9734               *pent = ent->next;
9735         }
9736
9737       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9738       for (; local_plt < end_local_plt; ++local_plt)
9739         {
9740           struct plt_entry *ent;
9741
9742           for (ent = *local_plt; ent != NULL; ent = ent->next)
9743             if (ent->plt.refcount > 0)
9744               {
9745                 s = htab->elf.iplt;
9746                 ent->plt.offset = s->size;
9747                 s->size += PLT_ENTRY_SIZE (htab);
9748
9749                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9750               }
9751             else
9752               ent->plt.offset = (bfd_vma) -1;
9753         }
9754     }
9755
9756   /* Allocate global sym .plt and .got entries, and space for global
9757      sym dynamic relocs.  */
9758   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9759   /* Stash the end of glink branch table.  */
9760   if (htab->glink != NULL)
9761     htab->glink->rawsize = htab->glink->size;
9762
9763   if (!htab->opd_abi && !info->shared)
9764     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9765
9766   first_tlsld = NULL;
9767   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9768     {
9769       struct got_entry *ent;
9770
9771       if (!is_ppc64_elf (ibfd))
9772         continue;
9773
9774       ent = ppc64_tlsld_got (ibfd);
9775       if (ent->got.refcount > 0)
9776         {
9777           if (!htab->do_multi_toc && first_tlsld != NULL)
9778             {
9779               ent->is_indirect = TRUE;
9780               ent->got.ent = first_tlsld;
9781             }
9782           else
9783             {
9784               if (first_tlsld == NULL)
9785                 first_tlsld = ent;
9786               s = ppc64_elf_tdata (ibfd)->got;
9787               ent->got.offset = s->size;
9788               ent->owner = ibfd;
9789               s->size += 16;
9790               if (info->shared)
9791                 {
9792                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9793                   srel->size += sizeof (Elf64_External_Rela);
9794                 }
9795             }
9796         }
9797       else
9798         ent->got.offset = (bfd_vma) -1;
9799     }
9800
9801   /* We now have determined the sizes of the various dynamic sections.
9802      Allocate memory for them.  */
9803   relocs = FALSE;
9804   for (s = dynobj->sections; s != NULL; s = s->next)
9805     {
9806       if ((s->flags & SEC_LINKER_CREATED) == 0)
9807         continue;
9808
9809       if (s == htab->brlt || s == htab->relbrlt)
9810         /* These haven't been allocated yet;  don't strip.  */
9811         continue;
9812       else if (s == htab->elf.sgot
9813                || s == htab->elf.splt
9814                || s == htab->elf.iplt
9815                || s == htab->glink
9816                || s == htab->dynbss)
9817         {
9818           /* Strip this section if we don't need it; see the
9819              comment below.  */
9820         }
9821       else if (s == htab->glink_eh_frame)
9822         {
9823           if (!bfd_is_abs_section (s->output_section))
9824             /* Not sized yet.  */
9825             continue;
9826         }
9827       else if (CONST_STRNEQ (s->name, ".rela"))
9828         {
9829           if (s->size != 0)
9830             {
9831               if (s != htab->elf.srelplt)
9832                 relocs = TRUE;
9833
9834               /* We use the reloc_count field as a counter if we need
9835                  to copy relocs into the output file.  */
9836               s->reloc_count = 0;
9837             }
9838         }
9839       else
9840         {
9841           /* It's not one of our sections, so don't allocate space.  */
9842           continue;
9843         }
9844
9845       if (s->size == 0)
9846         {
9847           /* If we don't need this section, strip it from the
9848              output file.  This is mostly to handle .rela.bss and
9849              .rela.plt.  We must create both sections in
9850              create_dynamic_sections, because they must be created
9851              before the linker maps input sections to output
9852              sections.  The linker does that before
9853              adjust_dynamic_symbol is called, and it is that
9854              function which decides whether anything needs to go
9855              into these sections.  */
9856           s->flags |= SEC_EXCLUDE;
9857           continue;
9858         }
9859
9860       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9861         continue;
9862
9863       /* Allocate memory for the section contents.  We use bfd_zalloc
9864          here in case unused entries are not reclaimed before the
9865          section's contents are written out.  This should not happen,
9866          but this way if it does we get a R_PPC64_NONE reloc in .rela
9867          sections instead of garbage.
9868          We also rely on the section contents being zero when writing
9869          the GOT.  */
9870       s->contents = bfd_zalloc (dynobj, s->size);
9871       if (s->contents == NULL)
9872         return FALSE;
9873     }
9874
9875   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9876     {
9877       if (!is_ppc64_elf (ibfd))
9878         continue;
9879
9880       s = ppc64_elf_tdata (ibfd)->got;
9881       if (s != NULL && s != htab->elf.sgot)
9882         {
9883           if (s->size == 0)
9884             s->flags |= SEC_EXCLUDE;
9885           else
9886             {
9887               s->contents = bfd_zalloc (ibfd, s->size);
9888               if (s->contents == NULL)
9889                 return FALSE;
9890             }
9891         }
9892       s = ppc64_elf_tdata (ibfd)->relgot;
9893       if (s != NULL)
9894         {
9895           if (s->size == 0)
9896             s->flags |= SEC_EXCLUDE;
9897           else
9898             {
9899               s->contents = bfd_zalloc (ibfd, s->size);
9900               if (s->contents == NULL)
9901                 return FALSE;
9902               relocs = TRUE;
9903               s->reloc_count = 0;
9904             }
9905         }
9906     }
9907
9908   if (htab->elf.dynamic_sections_created)
9909     {
9910       bfd_boolean tls_opt;
9911
9912       /* Add some entries to the .dynamic section.  We fill in the
9913          values later, in ppc64_elf_finish_dynamic_sections, but we
9914          must add the entries now so that we get the correct size for
9915          the .dynamic section.  The DT_DEBUG entry is filled in by the
9916          dynamic linker and used by the debugger.  */
9917 #define add_dynamic_entry(TAG, VAL) \
9918   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9919
9920       if (info->executable)
9921         {
9922           if (!add_dynamic_entry (DT_DEBUG, 0))
9923             return FALSE;
9924         }
9925
9926       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9927         {
9928           if (!add_dynamic_entry (DT_PLTGOT, 0)
9929               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9930               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9931               || !add_dynamic_entry (DT_JMPREL, 0)
9932               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9933             return FALSE;
9934         }
9935
9936       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9937         {
9938           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9939               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9940             return FALSE;
9941         }
9942
9943       tls_opt = (!htab->params->no_tls_get_addr_opt
9944                  && htab->tls_get_addr_fd != NULL
9945                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9946       if (tls_opt || !htab->opd_abi)
9947         {
9948           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9949             return FALSE;
9950         }
9951
9952       if (relocs)
9953         {
9954           if (!add_dynamic_entry (DT_RELA, 0)
9955               || !add_dynamic_entry (DT_RELASZ, 0)
9956               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9957             return FALSE;
9958
9959           /* If any dynamic relocs apply to a read-only section,
9960              then we need a DT_TEXTREL entry.  */
9961           if ((info->flags & DF_TEXTREL) == 0)
9962             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9963
9964           if ((info->flags & DF_TEXTREL) != 0)
9965             {
9966               if (!add_dynamic_entry (DT_TEXTREL, 0))
9967                 return FALSE;
9968             }
9969         }
9970     }
9971 #undef add_dynamic_entry
9972
9973   return TRUE;
9974 }
9975
9976 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9977
9978 static bfd_boolean
9979 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9980 {
9981   if (h->plt.plist != NULL
9982       && !h->def_regular
9983       && !h->pointer_equality_needed)
9984     return FALSE;
9985
9986   return _bfd_elf_hash_symbol (h);
9987 }
9988
9989 /* Determine the type of stub needed, if any, for a call.  */
9990
9991 static inline enum ppc_stub_type
9992 ppc_type_of_stub (asection *input_sec,
9993                   const Elf_Internal_Rela *rel,
9994                   struct ppc_link_hash_entry **hash,
9995                   struct plt_entry **plt_ent,
9996                   bfd_vma destination,
9997                   unsigned long local_off)
9998 {
9999   struct ppc_link_hash_entry *h = *hash;
10000   bfd_vma location;
10001   bfd_vma branch_offset;
10002   bfd_vma max_branch_offset;
10003   enum elf_ppc64_reloc_type r_type;
10004
10005   if (h != NULL)
10006     {
10007       struct plt_entry *ent;
10008       struct ppc_link_hash_entry *fdh = h;
10009       if (h->oh != NULL
10010           && h->oh->is_func_descriptor)
10011         {
10012           fdh = ppc_follow_link (h->oh);
10013           *hash = fdh;
10014         }
10015
10016       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10017         if (ent->addend == rel->r_addend
10018             && ent->plt.offset != (bfd_vma) -1)
10019           {
10020             *plt_ent = ent;
10021             return ppc_stub_plt_call;
10022           }
10023
10024       /* Here, we know we don't have a plt entry.  If we don't have a
10025          either a defined function descriptor or a defined entry symbol
10026          in a regular object file, then it is pointless trying to make
10027          any other type of stub.  */
10028       if (!is_static_defined (&fdh->elf)
10029           && !is_static_defined (&h->elf))
10030         return ppc_stub_none;
10031     }
10032   else if (elf_local_got_ents (input_sec->owner) != NULL)
10033     {
10034       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10035       struct plt_entry **local_plt = (struct plt_entry **)
10036         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10037       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10038
10039       if (local_plt[r_symndx] != NULL)
10040         {
10041           struct plt_entry *ent;
10042
10043           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10044             if (ent->addend == rel->r_addend
10045                 && ent->plt.offset != (bfd_vma) -1)
10046               {
10047                 *plt_ent = ent;
10048                 return ppc_stub_plt_call;
10049               }
10050         }
10051     }
10052
10053   /* Determine where the call point is.  */
10054   location = (input_sec->output_offset
10055               + input_sec->output_section->vma
10056               + rel->r_offset);
10057
10058   branch_offset = destination - location;
10059   r_type = ELF64_R_TYPE (rel->r_info);
10060
10061   /* Determine if a long branch stub is needed.  */
10062   max_branch_offset = 1 << 25;
10063   if (r_type != R_PPC64_REL24)
10064     max_branch_offset = 1 << 15;
10065
10066   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10067     /* We need a stub.  Figure out whether a long_branch or plt_branch
10068        is needed later.  */
10069     return ppc_stub_long_branch;
10070
10071   return ppc_stub_none;
10072 }
10073
10074 /* With power7 weakly ordered memory model, it is possible for ld.so
10075    to update a plt entry in one thread and have another thread see a
10076    stale zero toc entry.  To avoid this we need some sort of acquire
10077    barrier in the call stub.  One solution is to make the load of the
10078    toc word seem to appear to depend on the load of the function entry
10079    word.  Another solution is to test for r2 being zero, and branch to
10080    the appropriate glink entry if so.
10081
10082    .    fake dep barrier        compare
10083    .    ld 12,xxx(2)            ld 12,xxx(2)
10084    .    mtctr 12                mtctr 12
10085    .    xor 11,12,12            ld 2,xxx+8(2)
10086    .    add 2,2,11              cmpldi 2,0
10087    .    ld 2,xxx+8(2)           bnectr+
10088    .    bctr                    b <glink_entry>
10089
10090    The solution involving the compare turns out to be faster, so
10091    that's what we use unless the branch won't reach.  */
10092
10093 #define ALWAYS_USE_FAKE_DEP 0
10094 #define ALWAYS_EMIT_R2SAVE 0
10095
10096 #define PPC_LO(v) ((v) & 0xffff)
10097 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10098 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10099
10100 static inline unsigned int
10101 plt_stub_size (struct ppc_link_hash_table *htab,
10102                struct ppc_stub_hash_entry *stub_entry,
10103                bfd_vma off)
10104 {
10105   unsigned size = 12;
10106
10107   if (ALWAYS_EMIT_R2SAVE
10108       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10109     size += 4;
10110   if (PPC_HA (off) != 0)
10111     size += 4;
10112   if (htab->opd_abi)
10113     {
10114       size += 4;
10115       if (htab->params->plt_static_chain)
10116         size += 4;
10117       if (htab->params->plt_thread_safe)
10118         size += 8;
10119       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10120         size += 4;
10121     }
10122   if (stub_entry->h != NULL
10123       && (stub_entry->h == htab->tls_get_addr_fd
10124           || stub_entry->h == htab->tls_get_addr)
10125       && !htab->params->no_tls_get_addr_opt)
10126     size += 13 * 4;
10127   return size;
10128 }
10129
10130 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10131    then return the padding needed to do so.  */
10132 static inline unsigned int
10133 plt_stub_pad (struct ppc_link_hash_table *htab,
10134               struct ppc_stub_hash_entry *stub_entry,
10135               bfd_vma plt_off)
10136 {
10137   int stub_align = 1 << htab->params->plt_stub_align;
10138   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10139   bfd_vma stub_off = stub_entry->stub_sec->size;
10140
10141   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10142       > (stub_size & -stub_align))
10143     return stub_align - (stub_off & (stub_align - 1));
10144   return 0;
10145 }
10146
10147 /* Build a .plt call stub.  */
10148
10149 static inline bfd_byte *
10150 build_plt_stub (struct ppc_link_hash_table *htab,
10151                 struct ppc_stub_hash_entry *stub_entry,
10152                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10153 {
10154   bfd *obfd = htab->params->stub_bfd;
10155   bfd_boolean plt_load_toc = htab->opd_abi;
10156   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10157   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10158   bfd_boolean use_fake_dep = plt_thread_safe;
10159   bfd_vma cmp_branch_off = 0;
10160
10161   if (!ALWAYS_USE_FAKE_DEP
10162       && plt_load_toc
10163       && plt_thread_safe
10164       && !(stub_entry->h != NULL
10165            && (stub_entry->h == htab->tls_get_addr_fd
10166                || stub_entry->h == htab->tls_get_addr)
10167            && !htab->params->no_tls_get_addr_opt))
10168     {
10169       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10170       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10171                           / PLT_ENTRY_SIZE (htab));
10172       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10173       bfd_vma to, from;
10174
10175       if (pltindex > 32768)
10176         glinkoff += (pltindex - 32768) * 4;
10177       to = (glinkoff
10178             + htab->glink->output_offset
10179             + htab->glink->output_section->vma);
10180       from = (p - stub_entry->stub_sec->contents
10181               + 4 * (ALWAYS_EMIT_R2SAVE
10182                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10183               + 4 * (PPC_HA (offset) != 0)
10184               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10185                      != PPC_HA (offset))
10186               + 4 * (plt_static_chain != 0)
10187               + 20
10188               + stub_entry->stub_sec->output_offset
10189               + stub_entry->stub_sec->output_section->vma);
10190       cmp_branch_off = to - from;
10191       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10192     }
10193
10194   if (PPC_HA (offset) != 0)
10195     {
10196       if (r != NULL)
10197         {
10198           if (ALWAYS_EMIT_R2SAVE
10199               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10200             r[0].r_offset += 4;
10201           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10202           r[1].r_offset = r[0].r_offset + 4;
10203           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10204           r[1].r_addend = r[0].r_addend;
10205           if (plt_load_toc)
10206             {
10207               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10208                 {
10209                   r[2].r_offset = r[1].r_offset + 4;
10210                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10211                   r[2].r_addend = r[0].r_addend;
10212                 }
10213               else
10214                 {
10215                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10216                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10217                   r[2].r_addend = r[0].r_addend + 8;
10218                   if (plt_static_chain)
10219                     {
10220                       r[3].r_offset = r[2].r_offset + 4;
10221                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10222                       r[3].r_addend = r[0].r_addend + 16;
10223                     }
10224                 }
10225             }
10226         }
10227       if (ALWAYS_EMIT_R2SAVE
10228           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10229         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10230       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10231       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10232       if (plt_load_toc
10233           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10234         {
10235           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10236           offset = 0;
10237         }
10238       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10239       if (plt_load_toc)
10240         {
10241           if (use_fake_dep)
10242             {
10243               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10244               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10245             }
10246           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10247           if (plt_static_chain)
10248             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10249         }
10250     }
10251   else
10252     {
10253       if (r != NULL)
10254         {
10255           if (ALWAYS_EMIT_R2SAVE
10256               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10257             r[0].r_offset += 4;
10258           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10259           if (plt_load_toc)
10260             {
10261               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10262                 {
10263                   r[1].r_offset = r[0].r_offset + 4;
10264                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10265                   r[1].r_addend = r[0].r_addend;
10266                 }
10267               else
10268                 {
10269                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10270                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10271                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10272                   if (plt_static_chain)
10273                     {
10274                       r[2].r_offset = r[1].r_offset + 4;
10275                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10276                       r[2].r_addend = r[0].r_addend + 8;
10277                     }
10278                 }
10279             }
10280         }
10281       if (ALWAYS_EMIT_R2SAVE
10282           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10283         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10284       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10285       if (plt_load_toc
10286           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10287         {
10288           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10289           offset = 0;
10290         }
10291       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10292       if (plt_load_toc)
10293         {
10294           if (use_fake_dep)
10295             {
10296               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10297               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10298             }
10299           if (plt_static_chain)
10300             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10301           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10302         }
10303     }
10304   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10305     {
10306       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10307       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10308       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10309     }
10310   else
10311     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10312   return p;
10313 }
10314
10315 /* Build a special .plt call stub for __tls_get_addr.  */
10316
10317 #define LD_R11_0R3      0xe9630000
10318 #define LD_R12_0R3      0xe9830000
10319 #define MR_R0_R3        0x7c601b78
10320 #define CMPDI_R11_0     0x2c2b0000
10321 #define ADD_R3_R12_R13  0x7c6c6a14
10322 #define BEQLR           0x4d820020
10323 #define MR_R3_R0        0x7c030378
10324 #define STD_R11_0R1     0xf9610000
10325 #define BCTRL           0x4e800421
10326 #define LD_R11_0R1      0xe9610000
10327 #define MTLR_R11        0x7d6803a6
10328
10329 static inline bfd_byte *
10330 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10331                          struct ppc_stub_hash_entry *stub_entry,
10332                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10333 {
10334   bfd *obfd = htab->params->stub_bfd;
10335
10336   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10337   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10338   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10339   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10340   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10341   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10342   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10343   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10344   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10345
10346   if (r != NULL)
10347     r[0].r_offset += 9 * 4;
10348   p = build_plt_stub (htab, stub_entry, p, offset, r);
10349   bfd_put_32 (obfd, BCTRL, p - 4);
10350
10351   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10352   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10353   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10354   bfd_put_32 (obfd, BLR, p),                    p += 4;
10355
10356   return p;
10357 }
10358
10359 static Elf_Internal_Rela *
10360 get_relocs (asection *sec, int count)
10361 {
10362   Elf_Internal_Rela *relocs;
10363   struct bfd_elf_section_data *elfsec_data;
10364
10365   elfsec_data = elf_section_data (sec);
10366   relocs = elfsec_data->relocs;
10367   if (relocs == NULL)
10368     {
10369       bfd_size_type relsize;
10370       relsize = sec->reloc_count * sizeof (*relocs);
10371       relocs = bfd_alloc (sec->owner, relsize);
10372       if (relocs == NULL)
10373         return NULL;
10374       elfsec_data->relocs = relocs;
10375       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10376                                           sizeof (Elf_Internal_Shdr));
10377       if (elfsec_data->rela.hdr == NULL)
10378         return NULL;
10379       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10380                                         * sizeof (Elf64_External_Rela));
10381       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10382       sec->reloc_count = 0;
10383     }
10384   relocs += sec->reloc_count;
10385   sec->reloc_count += count;
10386   return relocs;
10387 }
10388
10389 static bfd_vma
10390 get_r2off (struct bfd_link_info *info,
10391            struct ppc_stub_hash_entry *stub_entry)
10392 {
10393   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10394   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10395
10396   if (r2off == 0)
10397     {
10398       /* Support linking -R objects.  Get the toc pointer from the
10399          opd entry.  */
10400       char buf[8];
10401       if (!htab->opd_abi)
10402         return r2off;
10403       asection *opd = stub_entry->h->elf.root.u.def.section;
10404       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10405
10406       if (strcmp (opd->name, ".opd") != 0
10407           || opd->reloc_count != 0)
10408         {
10409           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10410                                   stub_entry->h->elf.root.root.string);
10411           bfd_set_error (bfd_error_bad_value);
10412           return 0;
10413         }
10414       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10415         return 0;
10416       r2off = bfd_get_64 (opd->owner, buf);
10417       r2off -= elf_gp (info->output_bfd);
10418     }
10419   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10420   return r2off;
10421 }
10422
10423 static bfd_boolean
10424 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10425 {
10426   struct ppc_stub_hash_entry *stub_entry;
10427   struct ppc_branch_hash_entry *br_entry;
10428   struct bfd_link_info *info;
10429   struct ppc_link_hash_table *htab;
10430   bfd_byte *loc;
10431   bfd_byte *p;
10432   bfd_vma dest, off;
10433   int size;
10434   Elf_Internal_Rela *r;
10435   asection *plt;
10436
10437   /* Massage our args to the form they really have.  */
10438   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10439   info = in_arg;
10440
10441   htab = ppc_hash_table (info);
10442   if (htab == NULL)
10443     return FALSE;
10444
10445   /* Make a note of the offset within the stubs for this entry.  */
10446   stub_entry->stub_offset = stub_entry->stub_sec->size;
10447   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10448
10449   htab->stub_count[stub_entry->stub_type - 1] += 1;
10450   switch (stub_entry->stub_type)
10451     {
10452     case ppc_stub_long_branch:
10453     case ppc_stub_long_branch_r2off:
10454       /* Branches are relative.  This is where we are going to.  */
10455       dest = (stub_entry->target_value
10456               + stub_entry->target_section->output_offset
10457               + stub_entry->target_section->output_section->vma);
10458       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10459       off = dest;
10460
10461       /* And this is where we are coming from.  */
10462       off -= (stub_entry->stub_offset
10463               + stub_entry->stub_sec->output_offset
10464               + stub_entry->stub_sec->output_section->vma);
10465
10466       size = 4;
10467       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10468         {
10469           bfd_vma r2off = get_r2off (info, stub_entry);
10470
10471           if (r2off == 0)
10472             {
10473               htab->stub_error = TRUE;
10474               return FALSE;
10475             }
10476           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10477           loc += 4;
10478           size = 12;
10479           if (PPC_HA (r2off) != 0)
10480             {
10481               size = 16;
10482               bfd_put_32 (htab->params->stub_bfd,
10483                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10484               loc += 4;
10485             }
10486           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10487           loc += 4;
10488           off -= size - 4;
10489         }
10490       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10491
10492       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10493         {
10494           info->callbacks->einfo
10495             (_("%P: long branch stub `%s' offset overflow\n"),
10496              stub_entry->root.string);
10497           htab->stub_error = TRUE;
10498           return FALSE;
10499         }
10500
10501       if (info->emitrelocations)
10502         {
10503           r = get_relocs (stub_entry->stub_sec, 1);
10504           if (r == NULL)
10505             return FALSE;
10506           r->r_offset = loc - stub_entry->stub_sec->contents;
10507           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10508           r->r_addend = dest;
10509           if (stub_entry->h != NULL)
10510             {
10511               struct elf_link_hash_entry **hashes;
10512               unsigned long symndx;
10513               struct ppc_link_hash_entry *h;
10514
10515               hashes = elf_sym_hashes (htab->params->stub_bfd);
10516               if (hashes == NULL)
10517                 {
10518                   bfd_size_type hsize;
10519
10520                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10521                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10522                   if (hashes == NULL)
10523                     return FALSE;
10524                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10525                   htab->stub_globals = 1;
10526                 }
10527               symndx = htab->stub_globals++;
10528               h = stub_entry->h;
10529               hashes[symndx] = &h->elf;
10530               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10531               if (h->oh != NULL && h->oh->is_func)
10532                 h = ppc_follow_link (h->oh);
10533               if (h->elf.root.u.def.section != stub_entry->target_section)
10534                 /* H is an opd symbol.  The addend must be zero.  */
10535                 r->r_addend = 0;
10536               else
10537                 {
10538                   off = (h->elf.root.u.def.value
10539                          + h->elf.root.u.def.section->output_offset
10540                          + h->elf.root.u.def.section->output_section->vma);
10541                   r->r_addend -= off;
10542                 }
10543             }
10544         }
10545       break;
10546
10547     case ppc_stub_plt_branch:
10548     case ppc_stub_plt_branch_r2off:
10549       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10550                                          stub_entry->root.string + 9,
10551                                          FALSE, FALSE);
10552       if (br_entry == NULL)
10553         {
10554           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10555                                   stub_entry->root.string);
10556           htab->stub_error = TRUE;
10557           return FALSE;
10558         }
10559
10560       dest = (stub_entry->target_value
10561               + stub_entry->target_section->output_offset
10562               + stub_entry->target_section->output_section->vma);
10563       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10564         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10565
10566       bfd_put_64 (htab->brlt->owner, dest,
10567                   htab->brlt->contents + br_entry->offset);
10568
10569       if (br_entry->iter == htab->stub_iteration)
10570         {
10571           br_entry->iter = 0;
10572
10573           if (htab->relbrlt != NULL)
10574             {
10575               /* Create a reloc for the branch lookup table entry.  */
10576               Elf_Internal_Rela rela;
10577               bfd_byte *rl;
10578
10579               rela.r_offset = (br_entry->offset
10580                                + htab->brlt->output_offset
10581                                + htab->brlt->output_section->vma);
10582               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10583               rela.r_addend = dest;
10584
10585               rl = htab->relbrlt->contents;
10586               rl += (htab->relbrlt->reloc_count++
10587                      * sizeof (Elf64_External_Rela));
10588               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10589             }
10590           else if (info->emitrelocations)
10591             {
10592               r = get_relocs (htab->brlt, 1);
10593               if (r == NULL)
10594                 return FALSE;
10595               /* brlt, being SEC_LINKER_CREATED does not go through the
10596                  normal reloc processing.  Symbols and offsets are not
10597                  translated from input file to output file form, so
10598                  set up the offset per the output file.  */
10599               r->r_offset = (br_entry->offset
10600                              + htab->brlt->output_offset
10601                              + htab->brlt->output_section->vma);
10602               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10603               r->r_addend = dest;
10604             }
10605         }
10606
10607       dest = (br_entry->offset
10608               + htab->brlt->output_offset
10609               + htab->brlt->output_section->vma);
10610
10611       off = (dest
10612              - elf_gp (htab->brlt->output_section->owner)
10613              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10614
10615       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10616         {
10617           info->callbacks->einfo
10618             (_("%P: linkage table error against `%T'\n"),
10619              stub_entry->root.string);
10620           bfd_set_error (bfd_error_bad_value);
10621           htab->stub_error = TRUE;
10622           return FALSE;
10623         }
10624
10625       if (info->emitrelocations)
10626         {
10627           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10628           if (r == NULL)
10629             return FALSE;
10630           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10631           if (bfd_big_endian (info->output_bfd))
10632             r[0].r_offset += 2;
10633           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10634             r[0].r_offset += 4;
10635           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10636           r[0].r_addend = dest;
10637           if (PPC_HA (off) != 0)
10638             {
10639               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10640               r[1].r_offset = r[0].r_offset + 4;
10641               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10642               r[1].r_addend = r[0].r_addend;
10643             }
10644         }
10645
10646       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10647         {
10648           if (PPC_HA (off) != 0)
10649             {
10650               size = 16;
10651               bfd_put_32 (htab->params->stub_bfd,
10652                           ADDIS_R11_R2 | PPC_HA (off), loc);
10653               loc += 4;
10654               bfd_put_32 (htab->params->stub_bfd,
10655                           LD_R12_0R11 | PPC_LO (off), loc);
10656             }
10657           else
10658             {
10659               size = 12;
10660               bfd_put_32 (htab->params->stub_bfd,
10661                           LD_R12_0R2 | PPC_LO (off), loc);
10662             }
10663         }
10664       else
10665         {
10666           bfd_vma r2off = get_r2off (info, stub_entry);
10667
10668           if (r2off == 0 && htab->opd_abi)
10669             {
10670               htab->stub_error = TRUE;
10671               return FALSE;
10672             }
10673
10674           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10675           loc += 4;
10676           size = 16;
10677           if (PPC_HA (off) != 0)
10678             {
10679               size += 4;
10680               bfd_put_32 (htab->params->stub_bfd,
10681                           ADDIS_R11_R2 | PPC_HA (off), loc);
10682               loc += 4;
10683               bfd_put_32 (htab->params->stub_bfd,
10684                           LD_R12_0R11 | PPC_LO (off), loc);
10685             }
10686           else
10687             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10688
10689           if (PPC_HA (r2off) != 0)
10690             {
10691               size += 4;
10692               loc += 4;
10693               bfd_put_32 (htab->params->stub_bfd,
10694                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10695             }
10696           if (PPC_LO (r2off) != 0)
10697             {
10698               size += 4;
10699               loc += 4;
10700               bfd_put_32 (htab->params->stub_bfd,
10701                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10702             }
10703         }
10704       loc += 4;
10705       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10706       loc += 4;
10707       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10708       break;
10709
10710     case ppc_stub_plt_call:
10711     case ppc_stub_plt_call_r2save:
10712       if (stub_entry->h != NULL
10713           && stub_entry->h->is_func_descriptor
10714           && stub_entry->h->oh != NULL)
10715         {
10716           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10717
10718           /* If the old-ABI "dot-symbol" is undefined make it weak so
10719              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10720              FIXME: We used to define the symbol on one of the call
10721              stubs instead, which is why we test symbol section id
10722              against htab->top_id in various places.  Likely all
10723              these checks could now disappear.  */
10724           if (fh->elf.root.type == bfd_link_hash_undefined)
10725             fh->elf.root.type = bfd_link_hash_undefweak;
10726           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10727           fh->was_undefined = 0;
10728         }
10729
10730       /* Now build the stub.  */
10731       dest = stub_entry->plt_ent->plt.offset & ~1;
10732       if (dest >= (bfd_vma) -2)
10733         abort ();
10734
10735       plt = htab->elf.splt;
10736       if (!htab->elf.dynamic_sections_created
10737           || stub_entry->h == NULL
10738           || stub_entry->h->elf.dynindx == -1)
10739         plt = htab->elf.iplt;
10740
10741       dest += plt->output_offset + plt->output_section->vma;
10742
10743       if (stub_entry->h == NULL
10744           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10745         {
10746           Elf_Internal_Rela rela;
10747           bfd_byte *rl;
10748
10749           rela.r_offset = dest;
10750           if (htab->opd_abi)
10751             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10752           else
10753             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10754           rela.r_addend = (stub_entry->target_value
10755                            + stub_entry->target_section->output_offset
10756                            + stub_entry->target_section->output_section->vma);
10757
10758           rl = (htab->elf.irelplt->contents
10759                 + (htab->elf.irelplt->reloc_count++
10760                    * sizeof (Elf64_External_Rela)));
10761           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10762           stub_entry->plt_ent->plt.offset |= 1;
10763         }
10764
10765       off = (dest
10766              - elf_gp (plt->output_section->owner)
10767              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10768
10769       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10770         {
10771           info->callbacks->einfo
10772             (_("%P: linkage table error against `%T'\n"),
10773              stub_entry->h != NULL
10774              ? stub_entry->h->elf.root.root.string
10775              : "<local sym>");
10776           bfd_set_error (bfd_error_bad_value);
10777           htab->stub_error = TRUE;
10778           return FALSE;
10779         }
10780
10781       if (htab->params->plt_stub_align != 0)
10782         {
10783           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10784
10785           stub_entry->stub_sec->size += pad;
10786           stub_entry->stub_offset = stub_entry->stub_sec->size;
10787           loc += pad;
10788         }
10789
10790       r = NULL;
10791       if (info->emitrelocations)
10792         {
10793           r = get_relocs (stub_entry->stub_sec,
10794                           ((PPC_HA (off) != 0)
10795                            + (htab->opd_abi
10796                               ? 2 + (htab->params->plt_static_chain
10797                                      && PPC_HA (off + 16) == PPC_HA (off))
10798                               : 1)));
10799           if (r == NULL)
10800             return FALSE;
10801           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10802           if (bfd_big_endian (info->output_bfd))
10803             r[0].r_offset += 2;
10804           r[0].r_addend = dest;
10805         }
10806       if (stub_entry->h != NULL
10807           && (stub_entry->h == htab->tls_get_addr_fd
10808               || stub_entry->h == htab->tls_get_addr)
10809           && !htab->params->no_tls_get_addr_opt)
10810         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10811       else
10812         p = build_plt_stub (htab, stub_entry, loc, off, r);
10813       size = p - loc;
10814       break;
10815
10816     default:
10817       BFD_FAIL ();
10818       return FALSE;
10819     }
10820
10821   stub_entry->stub_sec->size += size;
10822
10823   if (htab->params->emit_stub_syms)
10824     {
10825       struct elf_link_hash_entry *h;
10826       size_t len1, len2;
10827       char *name;
10828       const char *const stub_str[] = { "long_branch",
10829                                        "long_branch_r2off",
10830                                        "plt_branch",
10831                                        "plt_branch_r2off",
10832                                        "plt_call",
10833                                        "plt_call" };
10834
10835       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10836       len2 = strlen (stub_entry->root.string);
10837       name = bfd_malloc (len1 + len2 + 2);
10838       if (name == NULL)
10839         return FALSE;
10840       memcpy (name, stub_entry->root.string, 9);
10841       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10842       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10843       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10844       if (h == NULL)
10845         return FALSE;
10846       if (h->root.type == bfd_link_hash_new)
10847         {
10848           h->root.type = bfd_link_hash_defined;
10849           h->root.u.def.section = stub_entry->stub_sec;
10850           h->root.u.def.value = stub_entry->stub_offset;
10851           h->ref_regular = 1;
10852           h->def_regular = 1;
10853           h->ref_regular_nonweak = 1;
10854           h->forced_local = 1;
10855           h->non_elf = 0;
10856         }
10857     }
10858
10859   return TRUE;
10860 }
10861
10862 /* As above, but don't actually build the stub.  Just bump offset so
10863    we know stub section sizes, and select plt_branch stubs where
10864    long_branch stubs won't do.  */
10865
10866 static bfd_boolean
10867 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10868 {
10869   struct ppc_stub_hash_entry *stub_entry;
10870   struct bfd_link_info *info;
10871   struct ppc_link_hash_table *htab;
10872   bfd_vma off;
10873   int size;
10874
10875   /* Massage our args to the form they really have.  */
10876   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10877   info = in_arg;
10878
10879   htab = ppc_hash_table (info);
10880   if (htab == NULL)
10881     return FALSE;
10882
10883   if (stub_entry->stub_type == ppc_stub_plt_call
10884       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10885     {
10886       asection *plt;
10887       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10888       if (off >= (bfd_vma) -2)
10889         abort ();
10890       plt = htab->elf.splt;
10891       if (!htab->elf.dynamic_sections_created
10892           || stub_entry->h == NULL
10893           || stub_entry->h->elf.dynindx == -1)
10894         plt = htab->elf.iplt;
10895       off += (plt->output_offset
10896               + plt->output_section->vma
10897               - elf_gp (plt->output_section->owner)
10898               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10899
10900       size = plt_stub_size (htab, stub_entry, off);
10901       if (htab->params->plt_stub_align)
10902         size += plt_stub_pad (htab, stub_entry, off);
10903       if (info->emitrelocations)
10904         {
10905           stub_entry->stub_sec->reloc_count
10906             += ((PPC_HA (off) != 0)
10907                 + (htab->opd_abi
10908                    ? 2 + (htab->params->plt_static_chain
10909                           && PPC_HA (off + 16) == PPC_HA (off))
10910                    : 1));
10911           stub_entry->stub_sec->flags |= SEC_RELOC;
10912         }
10913     }
10914   else
10915     {
10916       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10917          variants.  */
10918       bfd_vma r2off = 0;
10919       bfd_vma local_off = 0;
10920
10921       off = (stub_entry->target_value
10922              + stub_entry->target_section->output_offset
10923              + stub_entry->target_section->output_section->vma);
10924       off -= (stub_entry->stub_sec->size
10925               + stub_entry->stub_sec->output_offset
10926               + stub_entry->stub_sec->output_section->vma);
10927
10928       /* Reset the stub type from the plt variant in case we now
10929          can reach with a shorter stub.  */
10930       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10931         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10932
10933       size = 4;
10934       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10935         {
10936           r2off = get_r2off (info, stub_entry);
10937           if (r2off == 0 && htab->opd_abi)
10938             {
10939               htab->stub_error = TRUE;
10940               return FALSE;
10941             }
10942           size = 12;
10943           if (PPC_HA (r2off) != 0)
10944             size = 16;
10945           off -= size - 4;
10946         }
10947
10948       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10949
10950       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10951          Do the same for -R objects without function descriptors.  */
10952       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10953           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10954               && r2off == 0))
10955         {
10956           struct ppc_branch_hash_entry *br_entry;
10957
10958           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10959                                              stub_entry->root.string + 9,
10960                                              TRUE, FALSE);
10961           if (br_entry == NULL)
10962             {
10963               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10964                                       stub_entry->root.string);
10965               htab->stub_error = TRUE;
10966               return FALSE;
10967             }
10968
10969           if (br_entry->iter != htab->stub_iteration)
10970             {
10971               br_entry->iter = htab->stub_iteration;
10972               br_entry->offset = htab->brlt->size;
10973               htab->brlt->size += 8;
10974
10975               if (htab->relbrlt != NULL)
10976                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10977               else if (info->emitrelocations)
10978                 {
10979                   htab->brlt->reloc_count += 1;
10980                   htab->brlt->flags |= SEC_RELOC;
10981                 }
10982             }
10983
10984           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10985           off = (br_entry->offset
10986                  + htab->brlt->output_offset
10987                  + htab->brlt->output_section->vma
10988                  - elf_gp (htab->brlt->output_section->owner)
10989                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10990
10991           if (info->emitrelocations)
10992             {
10993               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10994               stub_entry->stub_sec->flags |= SEC_RELOC;
10995             }
10996
10997           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10998             {
10999               size = 12;
11000               if (PPC_HA (off) != 0)
11001                 size = 16;
11002             }
11003           else
11004             {
11005               size = 16;
11006               if (PPC_HA (off) != 0)
11007                 size += 4;
11008
11009               if (PPC_HA (r2off) != 0)
11010                 size += 4;
11011               if (PPC_LO (r2off) != 0)
11012                 size += 4;
11013             }
11014         }
11015       else if (info->emitrelocations)
11016         {
11017           stub_entry->stub_sec->reloc_count += 1;
11018           stub_entry->stub_sec->flags |= SEC_RELOC;
11019         }
11020     }
11021
11022   stub_entry->stub_sec->size += size;
11023   return TRUE;
11024 }
11025
11026 /* Set up various things so that we can make a list of input sections
11027    for each output section included in the link.  Returns -1 on error,
11028    0 when no stubs will be needed, and 1 on success.  */
11029
11030 int
11031 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11032 {
11033   bfd *input_bfd;
11034   int top_id, top_index, id;
11035   asection *section;
11036   asection **input_list;
11037   bfd_size_type amt;
11038   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11039
11040   if (htab == NULL)
11041     return -1;
11042
11043   /* Find the top input section id.  */
11044   for (input_bfd = info->input_bfds, top_id = 3;
11045        input_bfd != NULL;
11046        input_bfd = input_bfd->link_next)
11047     {
11048       for (section = input_bfd->sections;
11049            section != NULL;
11050            section = section->next)
11051         {
11052           if (top_id < section->id)
11053             top_id = section->id;
11054         }
11055     }
11056
11057   htab->top_id = top_id;
11058   amt = sizeof (struct map_stub) * (top_id + 1);
11059   htab->stub_group = bfd_zmalloc (amt);
11060   if (htab->stub_group == NULL)
11061     return -1;
11062
11063   /* Set toc_off for com, und, abs and ind sections.  */
11064   for (id = 0; id < 3; id++)
11065     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11066
11067   /* We can't use output_bfd->section_count here to find the top output
11068      section index as some sections may have been removed, and
11069      strip_excluded_output_sections doesn't renumber the indices.  */
11070   for (section = info->output_bfd->sections, top_index = 0;
11071        section != NULL;
11072        section = section->next)
11073     {
11074       if (top_index < section->index)
11075         top_index = section->index;
11076     }
11077
11078   htab->top_index = top_index;
11079   amt = sizeof (asection *) * (top_index + 1);
11080   input_list = bfd_zmalloc (amt);
11081   htab->input_list = input_list;
11082   if (input_list == NULL)
11083     return -1;
11084
11085   return 1;
11086 }
11087
11088 /* Set up for first pass at multitoc partitioning.  */
11089
11090 void
11091 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11092 {
11093   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11094
11095   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11096   htab->toc_bfd = NULL;
11097   htab->toc_first_sec = NULL;
11098 }
11099
11100 /* The linker repeatedly calls this function for each TOC input section
11101    and linker generated GOT section.  Group input bfds such that the toc
11102    within a group is less than 64k in size.  */
11103
11104 bfd_boolean
11105 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11106 {
11107   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11108   bfd_vma addr, off, limit;
11109
11110   if (htab == NULL)
11111     return FALSE;
11112
11113   if (!htab->second_toc_pass)
11114     {
11115       /* Keep track of the first .toc or .got section for this input bfd.  */
11116       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11117
11118       if (new_bfd)
11119         {
11120           htab->toc_bfd = isec->owner;
11121           htab->toc_first_sec = isec;
11122         }
11123
11124       addr = isec->output_offset + isec->output_section->vma;
11125       off = addr - htab->toc_curr;
11126       limit = 0x80008000;
11127       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11128         limit = 0x10000;
11129       if (off + isec->size > limit)
11130         {
11131           addr = (htab->toc_first_sec->output_offset
11132                   + htab->toc_first_sec->output_section->vma);
11133           htab->toc_curr = addr;
11134         }
11135
11136       /* toc_curr is the base address of this toc group.  Set elf_gp
11137          for the input section to be the offset relative to the
11138          output toc base plus 0x8000.  Making the input elf_gp an
11139          offset allows us to move the toc as a whole without
11140          recalculating input elf_gp.  */
11141       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11142       off += TOC_BASE_OFF;
11143
11144       /* Die if someone uses a linker script that doesn't keep input
11145          file .toc and .got together.  */
11146       if (new_bfd
11147           && elf_gp (isec->owner) != 0
11148           && elf_gp (isec->owner) != off)
11149         return FALSE;
11150
11151       elf_gp (isec->owner) = off;
11152       return TRUE;
11153     }
11154
11155   /* During the second pass toc_first_sec points to the start of
11156      a toc group, and toc_curr is used to track the old elf_gp.
11157      We use toc_bfd to ensure we only look at each bfd once.  */
11158   if (htab->toc_bfd == isec->owner)
11159     return TRUE;
11160   htab->toc_bfd = isec->owner;
11161
11162   if (htab->toc_first_sec == NULL
11163       || htab->toc_curr != elf_gp (isec->owner))
11164     {
11165       htab->toc_curr = elf_gp (isec->owner);
11166       htab->toc_first_sec = isec;
11167     }
11168   addr = (htab->toc_first_sec->output_offset
11169           + htab->toc_first_sec->output_section->vma);
11170   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11171   elf_gp (isec->owner) = off;
11172
11173   return TRUE;
11174 }
11175
11176 /* Called via elf_link_hash_traverse to merge GOT entries for global
11177    symbol H.  */
11178
11179 static bfd_boolean
11180 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11181 {
11182   if (h->root.type == bfd_link_hash_indirect)
11183     return TRUE;
11184
11185   merge_got_entries (&h->got.glist);
11186
11187   return TRUE;
11188 }
11189
11190 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11191    symbol H.  */
11192
11193 static bfd_boolean
11194 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11195 {
11196   struct got_entry *gent;
11197
11198   if (h->root.type == bfd_link_hash_indirect)
11199     return TRUE;
11200
11201   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11202     if (!gent->is_indirect)
11203       allocate_got (h, (struct bfd_link_info *) inf, gent);
11204   return TRUE;
11205 }
11206
11207 /* Called on the first multitoc pass after the last call to
11208    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11209    entries.  */
11210
11211 bfd_boolean
11212 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11213 {
11214   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11215   struct bfd *ibfd, *ibfd2;
11216   bfd_boolean done_something;
11217
11218   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11219
11220   if (!htab->do_multi_toc)
11221     return FALSE;
11222
11223   /* Merge global sym got entries within a toc group.  */
11224   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11225
11226   /* And tlsld_got.  */
11227   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11228     {
11229       struct got_entry *ent, *ent2;
11230
11231       if (!is_ppc64_elf (ibfd))
11232         continue;
11233
11234       ent = ppc64_tlsld_got (ibfd);
11235       if (!ent->is_indirect
11236           && ent->got.offset != (bfd_vma) -1)
11237         {
11238           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11239             {
11240               if (!is_ppc64_elf (ibfd2))
11241                 continue;
11242
11243               ent2 = ppc64_tlsld_got (ibfd2);
11244               if (!ent2->is_indirect
11245                   && ent2->got.offset != (bfd_vma) -1
11246                   && elf_gp (ibfd2) == elf_gp (ibfd))
11247                 {
11248                   ent2->is_indirect = TRUE;
11249                   ent2->got.ent = ent;
11250                 }
11251             }
11252         }
11253     }
11254
11255   /* Zap sizes of got sections.  */
11256   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11257   htab->elf.irelplt->size -= htab->got_reli_size;
11258   htab->got_reli_size = 0;
11259
11260   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11261     {
11262       asection *got, *relgot;
11263
11264       if (!is_ppc64_elf (ibfd))
11265         continue;
11266
11267       got = ppc64_elf_tdata (ibfd)->got;
11268       if (got != NULL)
11269         {
11270           got->rawsize = got->size;
11271           got->size = 0;
11272           relgot = ppc64_elf_tdata (ibfd)->relgot;
11273           relgot->rawsize = relgot->size;
11274           relgot->size = 0;
11275         }
11276     }
11277
11278   /* Now reallocate the got, local syms first.  We don't need to
11279      allocate section contents again since we never increase size.  */
11280   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11281     {
11282       struct got_entry **lgot_ents;
11283       struct got_entry **end_lgot_ents;
11284       struct plt_entry **local_plt;
11285       struct plt_entry **end_local_plt;
11286       unsigned char *lgot_masks;
11287       bfd_size_type locsymcount;
11288       Elf_Internal_Shdr *symtab_hdr;
11289       asection *s;
11290
11291       if (!is_ppc64_elf (ibfd))
11292         continue;
11293
11294       lgot_ents = elf_local_got_ents (ibfd);
11295       if (!lgot_ents)
11296         continue;
11297
11298       symtab_hdr = &elf_symtab_hdr (ibfd);
11299       locsymcount = symtab_hdr->sh_info;
11300       end_lgot_ents = lgot_ents + locsymcount;
11301       local_plt = (struct plt_entry **) end_lgot_ents;
11302       end_local_plt = local_plt + locsymcount;
11303       lgot_masks = (unsigned char *) end_local_plt;
11304       s = ppc64_elf_tdata (ibfd)->got;
11305       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11306         {
11307           struct got_entry *ent;
11308
11309           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11310             {
11311               unsigned int ent_size = 8;
11312               unsigned int rel_size = sizeof (Elf64_External_Rela);
11313
11314               ent->got.offset = s->size;
11315               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11316                 {
11317                   ent_size *= 2;
11318                   rel_size *= 2;
11319                 }
11320               s->size += ent_size;
11321               if ((*lgot_masks & PLT_IFUNC) != 0)
11322                 {
11323                   htab->elf.irelplt->size += rel_size;
11324                   htab->got_reli_size += rel_size;
11325                 }
11326               else if (info->shared)
11327                 {
11328                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11329                   srel->size += rel_size;
11330                 }
11331             }
11332         }
11333     }
11334
11335   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11336
11337   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11338     {
11339       struct got_entry *ent;
11340
11341       if (!is_ppc64_elf (ibfd))
11342         continue;
11343
11344       ent = ppc64_tlsld_got (ibfd);
11345       if (!ent->is_indirect
11346           && ent->got.offset != (bfd_vma) -1)
11347         {
11348           asection *s = ppc64_elf_tdata (ibfd)->got;
11349           ent->got.offset = s->size;
11350           s->size += 16;
11351           if (info->shared)
11352             {
11353               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11354               srel->size += sizeof (Elf64_External_Rela);
11355             }
11356         }
11357     }
11358
11359   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11360   if (!done_something)
11361     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11362       {
11363         asection *got;
11364
11365         if (!is_ppc64_elf (ibfd))
11366           continue;
11367
11368         got = ppc64_elf_tdata (ibfd)->got;
11369         if (got != NULL)
11370           {
11371             done_something = got->rawsize != got->size;
11372             if (done_something)
11373               break;
11374           }
11375       }
11376
11377   if (done_something)
11378     (*htab->params->layout_sections_again) ();
11379
11380   /* Set up for second pass over toc sections to recalculate elf_gp
11381      on input sections.  */
11382   htab->toc_bfd = NULL;
11383   htab->toc_first_sec = NULL;
11384   htab->second_toc_pass = TRUE;
11385   return done_something;
11386 }
11387
11388 /* Called after second pass of multitoc partitioning.  */
11389
11390 void
11391 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11392 {
11393   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11394
11395   /* After the second pass, toc_curr tracks the TOC offset used
11396      for code sections below in ppc64_elf_next_input_section.  */
11397   htab->toc_curr = TOC_BASE_OFF;
11398 }
11399
11400 /* No toc references were found in ISEC.  If the code in ISEC makes no
11401    calls, then there's no need to use toc adjusting stubs when branching
11402    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11403    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11404    needed, and 2 if a cyclical call-graph was found but no other reason
11405    for a stub was detected.  If called from the top level, a return of
11406    2 means the same as a return of 0.  */
11407
11408 static int
11409 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11410 {
11411   int ret;
11412
11413   /* Mark this section as checked.  */
11414   isec->call_check_done = 1;
11415
11416   /* We know none of our code bearing sections will need toc stubs.  */
11417   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11418     return 0;
11419
11420   if (isec->size == 0)
11421     return 0;
11422
11423   if (isec->output_section == NULL)
11424     return 0;
11425
11426   ret = 0;
11427   if (isec->reloc_count != 0)
11428     {
11429       Elf_Internal_Rela *relstart, *rel;
11430       Elf_Internal_Sym *local_syms;
11431       struct ppc_link_hash_table *htab;
11432
11433       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11434                                             info->keep_memory);
11435       if (relstart == NULL)
11436         return -1;
11437
11438       /* Look for branches to outside of this section.  */
11439       local_syms = NULL;
11440       htab = ppc_hash_table (info);
11441       if (htab == NULL)
11442         return -1;
11443
11444       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11445         {
11446           enum elf_ppc64_reloc_type r_type;
11447           unsigned long r_symndx;
11448           struct elf_link_hash_entry *h;
11449           struct ppc_link_hash_entry *eh;
11450           Elf_Internal_Sym *sym;
11451           asection *sym_sec;
11452           struct _opd_sec_data *opd;
11453           bfd_vma sym_value;
11454           bfd_vma dest;
11455
11456           r_type = ELF64_R_TYPE (rel->r_info);
11457           if (r_type != R_PPC64_REL24
11458               && r_type != R_PPC64_REL14
11459               && r_type != R_PPC64_REL14_BRTAKEN
11460               && r_type != R_PPC64_REL14_BRNTAKEN)
11461             continue;
11462
11463           r_symndx = ELF64_R_SYM (rel->r_info);
11464           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11465                           isec->owner))
11466             {
11467               ret = -1;
11468               break;
11469             }
11470
11471           /* Calls to dynamic lib functions go through a plt call stub
11472              that uses r2.  */
11473           eh = (struct ppc_link_hash_entry *) h;
11474           if (eh != NULL
11475               && (eh->elf.plt.plist != NULL
11476                   || (eh->oh != NULL
11477                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11478             {
11479               ret = 1;
11480               break;
11481             }
11482
11483           if (sym_sec == NULL)
11484             /* Ignore other undefined symbols.  */
11485             continue;
11486
11487           /* Assume branches to other sections not included in the
11488              link need stubs too, to cover -R and absolute syms.  */
11489           if (sym_sec->output_section == NULL)
11490             {
11491               ret = 1;
11492               break;
11493             }
11494
11495           if (h == NULL)
11496             sym_value = sym->st_value;
11497           else
11498             {
11499               if (h->root.type != bfd_link_hash_defined
11500                   && h->root.type != bfd_link_hash_defweak)
11501                 abort ();
11502               sym_value = h->root.u.def.value;
11503             }
11504           sym_value += rel->r_addend;
11505
11506           /* If this branch reloc uses an opd sym, find the code section.  */
11507           opd = get_opd_info (sym_sec);
11508           if (opd != NULL)
11509             {
11510               if (h == NULL && opd->adjust != NULL)
11511                 {
11512                   long adjust;
11513
11514                   adjust = opd->adjust[sym->st_value / 8];
11515                   if (adjust == -1)
11516                     /* Assume deleted functions won't ever be called.  */
11517                     continue;
11518                   sym_value += adjust;
11519                 }
11520
11521               dest = opd_entry_value (sym_sec, sym_value,
11522                                       &sym_sec, NULL, FALSE);
11523               if (dest == (bfd_vma) -1)
11524                 continue;
11525             }
11526           else
11527             dest = (sym_value
11528                     + sym_sec->output_offset
11529                     + sym_sec->output_section->vma);
11530
11531           /* Ignore branch to self.  */
11532           if (sym_sec == isec)
11533             continue;
11534
11535           /* If the called function uses the toc, we need a stub.  */
11536           if (sym_sec->has_toc_reloc
11537               || sym_sec->makes_toc_func_call)
11538             {
11539               ret = 1;
11540               break;
11541             }
11542
11543           /* Assume any branch that needs a long branch stub might in fact
11544              need a plt_branch stub.  A plt_branch stub uses r2.  */
11545           else if (dest - (isec->output_offset
11546                            + isec->output_section->vma
11547                            + rel->r_offset) + (1 << 25)
11548                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11549                                                              ? h->other
11550                                                              : sym->st_other))
11551             {
11552               ret = 1;
11553               break;
11554             }
11555
11556           /* If calling back to a section in the process of being
11557              tested, we can't say for sure that no toc adjusting stubs
11558              are needed, so don't return zero.  */
11559           else if (sym_sec->call_check_in_progress)
11560             ret = 2;
11561
11562           /* Branches to another section that itself doesn't have any TOC
11563              references are OK.  Recursively call ourselves to check.  */
11564           else if (!sym_sec->call_check_done)
11565             {
11566               int recur;
11567
11568               /* Mark current section as indeterminate, so that other
11569                  sections that call back to current won't be marked as
11570                  known.  */
11571               isec->call_check_in_progress = 1;
11572               recur = toc_adjusting_stub_needed (info, sym_sec);
11573               isec->call_check_in_progress = 0;
11574
11575               if (recur != 0)
11576                 {
11577                   ret = recur;
11578                   if (recur != 2)
11579                     break;
11580                 }
11581             }
11582         }
11583
11584       if (local_syms != NULL
11585           && (elf_symtab_hdr (isec->owner).contents
11586               != (unsigned char *) local_syms))
11587         free (local_syms);
11588       if (elf_section_data (isec)->relocs != relstart)
11589         free (relstart);
11590     }
11591
11592   if ((ret & 1) == 0
11593       && isec->map_head.s != NULL
11594       && (strcmp (isec->output_section->name, ".init") == 0
11595           || strcmp (isec->output_section->name, ".fini") == 0))
11596     {
11597       if (isec->map_head.s->has_toc_reloc
11598           || isec->map_head.s->makes_toc_func_call)
11599         ret = 1;
11600       else if (!isec->map_head.s->call_check_done)
11601         {
11602           int recur;
11603           isec->call_check_in_progress = 1;
11604           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11605           isec->call_check_in_progress = 0;
11606           if (recur != 0)
11607             ret = recur;
11608         }
11609     }
11610
11611   if (ret == 1)
11612     isec->makes_toc_func_call = 1;
11613
11614   return ret;
11615 }
11616
11617 /* The linker repeatedly calls this function for each input section,
11618    in the order that input sections are linked into output sections.
11619    Build lists of input sections to determine groupings between which
11620    we may insert linker stubs.  */
11621
11622 bfd_boolean
11623 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11624 {
11625   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11626
11627   if (htab == NULL)
11628     return FALSE;
11629
11630   if ((isec->output_section->flags & SEC_CODE) != 0
11631       && isec->output_section->index <= htab->top_index)
11632     {
11633       asection **list = htab->input_list + isec->output_section->index;
11634       /* Steal the link_sec pointer for our list.  */
11635 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11636       /* This happens to make the list in reverse order,
11637          which is what we want.  */
11638       PREV_SEC (isec) = *list;
11639       *list = isec;
11640     }
11641
11642   if (htab->multi_toc_needed)
11643     {
11644       /* Analyse sections that aren't already flagged as needing a
11645          valid toc pointer.  Exclude .fixup for the linux kernel.
11646          .fixup contains branches, but only back to the function that
11647          hit an exception.  */
11648       if (!(isec->has_toc_reloc
11649             || (isec->flags & SEC_CODE) == 0
11650             || strcmp (isec->name, ".fixup") == 0
11651             || isec->call_check_done))
11652         {
11653           if (toc_adjusting_stub_needed (info, isec) < 0)
11654             return FALSE;
11655         }
11656       /* Make all sections use the TOC assigned for this object file.
11657          This will be wrong for pasted sections;  We fix that in
11658          check_pasted_section().  */
11659       if (elf_gp (isec->owner) != 0)
11660         htab->toc_curr = elf_gp (isec->owner);
11661     }
11662
11663   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11664   return TRUE;
11665 }
11666
11667 /* Check that all .init and .fini sections use the same toc, if they
11668    have toc relocs.  */
11669
11670 static bfd_boolean
11671 check_pasted_section (struct bfd_link_info *info, const char *name)
11672 {
11673   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11674
11675   if (o != NULL)
11676     {
11677       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11678       bfd_vma toc_off = 0;
11679       asection *i;
11680
11681       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11682         if (i->has_toc_reloc)
11683           {
11684             if (toc_off == 0)
11685               toc_off = htab->stub_group[i->id].toc_off;
11686             else if (toc_off != htab->stub_group[i->id].toc_off)
11687               return FALSE;
11688           }
11689
11690       if (toc_off == 0)
11691         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11692           if (i->makes_toc_func_call)
11693             {
11694               toc_off = htab->stub_group[i->id].toc_off;
11695               break;
11696             }
11697
11698       /* Make sure the whole pasted function uses the same toc offset.  */
11699       if (toc_off != 0)
11700         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11701           htab->stub_group[i->id].toc_off = toc_off;
11702     }
11703   return TRUE;
11704 }
11705
11706 bfd_boolean
11707 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11708 {
11709   return (check_pasted_section (info, ".init")
11710           & check_pasted_section (info, ".fini"));
11711 }
11712
11713 /* See whether we can group stub sections together.  Grouping stub
11714    sections may result in fewer stubs.  More importantly, we need to
11715    put all .init* and .fini* stubs at the beginning of the .init or
11716    .fini output sections respectively, because glibc splits the
11717    _init and _fini functions into multiple parts.  Putting a stub in
11718    the middle of a function is not a good idea.  */
11719
11720 static void
11721 group_sections (struct ppc_link_hash_table *htab,
11722                 bfd_size_type stub_group_size,
11723                 bfd_boolean stubs_always_before_branch)
11724 {
11725   asection **list;
11726   bfd_size_type stub14_group_size;
11727   bfd_boolean suppress_size_errors;
11728
11729   suppress_size_errors = FALSE;
11730   stub14_group_size = stub_group_size;
11731   if (stub_group_size == 1)
11732     {
11733       /* Default values.  */
11734       if (stubs_always_before_branch)
11735         {
11736           stub_group_size = 0x1e00000;
11737           stub14_group_size = 0x7800;
11738         }
11739       else
11740         {
11741           stub_group_size = 0x1c00000;
11742           stub14_group_size = 0x7000;
11743         }
11744       suppress_size_errors = TRUE;
11745     }
11746
11747   list = htab->input_list + htab->top_index;
11748   do
11749     {
11750       asection *tail = *list;
11751       while (tail != NULL)
11752         {
11753           asection *curr;
11754           asection *prev;
11755           bfd_size_type total;
11756           bfd_boolean big_sec;
11757           bfd_vma curr_toc;
11758
11759           curr = tail;
11760           total = tail->size;
11761           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11762                              && ppc64_elf_section_data (tail)->has_14bit_branch
11763                              ? stub14_group_size : stub_group_size);
11764           if (big_sec && !suppress_size_errors)
11765             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11766                                      tail->owner, tail);
11767           curr_toc = htab->stub_group[tail->id].toc_off;
11768
11769           while ((prev = PREV_SEC (curr)) != NULL
11770                  && ((total += curr->output_offset - prev->output_offset)
11771                      < (ppc64_elf_section_data (prev) != NULL
11772                         && ppc64_elf_section_data (prev)->has_14bit_branch
11773                         ? stub14_group_size : stub_group_size))
11774                  && htab->stub_group[prev->id].toc_off == curr_toc)
11775             curr = prev;
11776
11777           /* OK, the size from the start of CURR to the end is less
11778              than stub_group_size and thus can be handled by one stub
11779              section.  (or the tail section is itself larger than
11780              stub_group_size, in which case we may be toast.)  We
11781              should really be keeping track of the total size of stubs
11782              added here, as stubs contribute to the final output
11783              section size.  That's a little tricky, and this way will
11784              only break if stubs added make the total size more than
11785              2^25, ie. for the default stub_group_size, if stubs total
11786              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11787           do
11788             {
11789               prev = PREV_SEC (tail);
11790               /* Set up this stub group.  */
11791               htab->stub_group[tail->id].link_sec = curr;
11792             }
11793           while (tail != curr && (tail = prev) != NULL);
11794
11795           /* But wait, there's more!  Input sections up to stub_group_size
11796              bytes before the stub section can be handled by it too.
11797              Don't do this if we have a really large section after the
11798              stubs, as adding more stubs increases the chance that
11799              branches may not reach into the stub section.  */
11800           if (!stubs_always_before_branch && !big_sec)
11801             {
11802               total = 0;
11803               while (prev != NULL
11804                      && ((total += tail->output_offset - prev->output_offset)
11805                          < (ppc64_elf_section_data (prev) != NULL
11806                             && ppc64_elf_section_data (prev)->has_14bit_branch
11807                             ? stub14_group_size : stub_group_size))
11808                      && htab->stub_group[prev->id].toc_off == curr_toc)
11809                 {
11810                   tail = prev;
11811                   prev = PREV_SEC (tail);
11812                   htab->stub_group[tail->id].link_sec = curr;
11813                 }
11814             }
11815           tail = prev;
11816         }
11817     }
11818   while (list-- != htab->input_list);
11819   free (htab->input_list);
11820 #undef PREV_SEC
11821 }
11822
11823 static const unsigned char glink_eh_frame_cie[] =
11824 {
11825   0, 0, 0, 16,                          /* length.  */
11826   0, 0, 0, 0,                           /* id.  */
11827   1,                                    /* CIE version.  */
11828   'z', 'R', 0,                          /* Augmentation string.  */
11829   4,                                    /* Code alignment.  */
11830   0x78,                                 /* Data alignment.  */
11831   65,                                   /* RA reg.  */
11832   1,                                    /* Augmentation size.  */
11833   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11834   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11835 };
11836
11837 /* Stripping output sections is normally done before dynamic section
11838    symbols have been allocated.  This function is called later, and
11839    handles cases like htab->brlt which is mapped to its own output
11840    section.  */
11841
11842 static void
11843 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11844 {
11845   if (isec->size == 0
11846       && isec->output_section->size == 0
11847       && !(isec->output_section->flags & SEC_KEEP)
11848       && !bfd_section_removed_from_list (info->output_bfd,
11849                                          isec->output_section)
11850       && elf_section_data (isec->output_section)->dynindx == 0)
11851     {
11852       isec->output_section->flags |= SEC_EXCLUDE;
11853       bfd_section_list_remove (info->output_bfd, isec->output_section);
11854       info->output_bfd->section_count--;
11855     }
11856 }
11857
11858 /* Determine and set the size of the stub section for a final link.
11859
11860    The basic idea here is to examine all the relocations looking for
11861    PC-relative calls to a target that is unreachable with a "bl"
11862    instruction.  */
11863
11864 bfd_boolean
11865 ppc64_elf_size_stubs (struct bfd_link_info *info)
11866 {
11867   bfd_size_type stub_group_size;
11868   bfd_boolean stubs_always_before_branch;
11869   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11870
11871   if (htab == NULL)
11872     return FALSE;
11873
11874   if (htab->params->plt_thread_safe == -1 && !info->executable)
11875     htab->params->plt_thread_safe = 1;
11876   if (!htab->opd_abi)
11877     htab->params->plt_thread_safe = 0;
11878   else if (htab->params->plt_thread_safe == -1)
11879     {
11880       static const char *const thread_starter[] =
11881         {
11882           "pthread_create",
11883           /* libstdc++ */
11884           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11885           /* librt */
11886           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11887           "mq_notify", "create_timer",
11888           /* libanl */
11889           "getaddrinfo_a",
11890           /* libgomp */
11891           "GOMP_parallel_start",
11892           "GOMP_parallel_loop_static_start",
11893           "GOMP_parallel_loop_dynamic_start",
11894           "GOMP_parallel_loop_guided_start",
11895           "GOMP_parallel_loop_runtime_start",
11896           "GOMP_parallel_sections_start",
11897         };
11898       unsigned i;
11899
11900       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11901         {
11902           struct elf_link_hash_entry *h;
11903           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11904                                     FALSE, FALSE, TRUE);
11905           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11906           if (htab->params->plt_thread_safe)
11907             break;
11908         }
11909     }
11910   stubs_always_before_branch = htab->params->group_size < 0;
11911   if (htab->params->group_size < 0)
11912     stub_group_size = -htab->params->group_size;
11913   else
11914     stub_group_size = htab->params->group_size;
11915
11916   group_sections (htab, stub_group_size, stubs_always_before_branch);
11917
11918   while (1)
11919     {
11920       bfd *input_bfd;
11921       unsigned int bfd_indx;
11922       asection *stub_sec;
11923
11924       htab->stub_iteration += 1;
11925
11926       for (input_bfd = info->input_bfds, bfd_indx = 0;
11927            input_bfd != NULL;
11928            input_bfd = input_bfd->link_next, bfd_indx++)
11929         {
11930           Elf_Internal_Shdr *symtab_hdr;
11931           asection *section;
11932           Elf_Internal_Sym *local_syms = NULL;
11933
11934           if (!is_ppc64_elf (input_bfd))
11935             continue;
11936
11937           /* We'll need the symbol table in a second.  */
11938           symtab_hdr = &elf_symtab_hdr (input_bfd);
11939           if (symtab_hdr->sh_info == 0)
11940             continue;
11941
11942           /* Walk over each section attached to the input bfd.  */
11943           for (section = input_bfd->sections;
11944                section != NULL;
11945                section = section->next)
11946             {
11947               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11948
11949               /* If there aren't any relocs, then there's nothing more
11950                  to do.  */
11951               if ((section->flags & SEC_RELOC) == 0
11952                   || (section->flags & SEC_ALLOC) == 0
11953                   || (section->flags & SEC_LOAD) == 0
11954                   || (section->flags & SEC_CODE) == 0
11955                   || section->reloc_count == 0)
11956                 continue;
11957
11958               /* If this section is a link-once section that will be
11959                  discarded, then don't create any stubs.  */
11960               if (section->output_section == NULL
11961                   || section->output_section->owner != info->output_bfd)
11962                 continue;
11963
11964               /* Get the relocs.  */
11965               internal_relocs
11966                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11967                                              info->keep_memory);
11968               if (internal_relocs == NULL)
11969                 goto error_ret_free_local;
11970
11971               /* Now examine each relocation.  */
11972               irela = internal_relocs;
11973               irelaend = irela + section->reloc_count;
11974               for (; irela < irelaend; irela++)
11975                 {
11976                   enum elf_ppc64_reloc_type r_type;
11977                   unsigned int r_indx;
11978                   enum ppc_stub_type stub_type;
11979                   struct ppc_stub_hash_entry *stub_entry;
11980                   asection *sym_sec, *code_sec;
11981                   bfd_vma sym_value, code_value;
11982                   bfd_vma destination;
11983                   unsigned long local_off;
11984                   bfd_boolean ok_dest;
11985                   struct ppc_link_hash_entry *hash;
11986                   struct ppc_link_hash_entry *fdh;
11987                   struct elf_link_hash_entry *h;
11988                   Elf_Internal_Sym *sym;
11989                   char *stub_name;
11990                   const asection *id_sec;
11991                   struct _opd_sec_data *opd;
11992                   struct plt_entry *plt_ent;
11993
11994                   r_type = ELF64_R_TYPE (irela->r_info);
11995                   r_indx = ELF64_R_SYM (irela->r_info);
11996
11997                   if (r_type >= R_PPC64_max)
11998                     {
11999                       bfd_set_error (bfd_error_bad_value);
12000                       goto error_ret_free_internal;
12001                     }
12002
12003                   /* Only look for stubs on branch instructions.  */
12004                   if (r_type != R_PPC64_REL24
12005                       && r_type != R_PPC64_REL14
12006                       && r_type != R_PPC64_REL14_BRTAKEN
12007                       && r_type != R_PPC64_REL14_BRNTAKEN)
12008                     continue;
12009
12010                   /* Now determine the call target, its name, value,
12011                      section.  */
12012                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12013                                   r_indx, input_bfd))
12014                     goto error_ret_free_internal;
12015                   hash = (struct ppc_link_hash_entry *) h;
12016
12017                   ok_dest = FALSE;
12018                   fdh = NULL;
12019                   sym_value = 0;
12020                   if (hash == NULL)
12021                     {
12022                       sym_value = sym->st_value;
12023                       ok_dest = TRUE;
12024                     }
12025                   else if (hash->elf.root.type == bfd_link_hash_defined
12026                            || hash->elf.root.type == bfd_link_hash_defweak)
12027                     {
12028                       sym_value = hash->elf.root.u.def.value;
12029                       if (sym_sec->output_section != NULL)
12030                         ok_dest = TRUE;
12031                     }
12032                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12033                            || hash->elf.root.type == bfd_link_hash_undefined)
12034                     {
12035                       /* Recognise an old ABI func code entry sym, and
12036                          use the func descriptor sym instead if it is
12037                          defined.  */
12038                       if (hash->elf.root.root.string[0] == '.'
12039                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12040                         {
12041                           if (fdh->elf.root.type == bfd_link_hash_defined
12042                               || fdh->elf.root.type == bfd_link_hash_defweak)
12043                             {
12044                               sym_sec = fdh->elf.root.u.def.section;
12045                               sym_value = fdh->elf.root.u.def.value;
12046                               if (sym_sec->output_section != NULL)
12047                                 ok_dest = TRUE;
12048                             }
12049                           else
12050                             fdh = NULL;
12051                         }
12052                     }
12053                   else
12054                     {
12055                       bfd_set_error (bfd_error_bad_value);
12056                       goto error_ret_free_internal;
12057                     }
12058
12059                   destination = 0;
12060                   local_off = 0;
12061                   if (ok_dest)
12062                     {
12063                       sym_value += irela->r_addend;
12064                       destination = (sym_value
12065                                      + sym_sec->output_offset
12066                                      + sym_sec->output_section->vma);
12067                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12068                                                             ? hash->elf.other
12069                                                             : sym->st_other);
12070                     }
12071
12072                   code_sec = sym_sec;
12073                   code_value = sym_value;
12074                   opd = get_opd_info (sym_sec);
12075                   if (opd != NULL)
12076                     {
12077                       bfd_vma dest;
12078
12079                       if (hash == NULL && opd->adjust != NULL)
12080                         {
12081                           long adjust = opd->adjust[sym_value / 8];
12082                           if (adjust == -1)
12083                             continue;
12084                           code_value += adjust;
12085                           sym_value += adjust;
12086                         }
12087                       dest = opd_entry_value (sym_sec, sym_value,
12088                                               &code_sec, &code_value, FALSE);
12089                       if (dest != (bfd_vma) -1)
12090                         {
12091                           destination = dest;
12092                           if (fdh != NULL)
12093                             {
12094                               /* Fixup old ABI sym to point at code
12095                                  entry.  */
12096                               hash->elf.root.type = bfd_link_hash_defweak;
12097                               hash->elf.root.u.def.section = code_sec;
12098                               hash->elf.root.u.def.value = code_value;
12099                             }
12100                         }
12101                     }
12102
12103                   /* Determine what (if any) linker stub is needed.  */
12104                   plt_ent = NULL;
12105                   stub_type = ppc_type_of_stub (section, irela, &hash,
12106                                                 &plt_ent, destination,
12107                                                 local_off);
12108
12109                   if (stub_type != ppc_stub_plt_call)
12110                     {
12111                       /* Check whether we need a TOC adjusting stub.
12112                          Since the linker pastes together pieces from
12113                          different object files when creating the
12114                          _init and _fini functions, it may be that a
12115                          call to what looks like a local sym is in
12116                          fact a call needing a TOC adjustment.  */
12117                       if (code_sec != NULL
12118                           && code_sec->output_section != NULL
12119                           && (htab->stub_group[code_sec->id].toc_off
12120                               != htab->stub_group[section->id].toc_off)
12121                           && (code_sec->has_toc_reloc
12122                               || code_sec->makes_toc_func_call))
12123                         stub_type = ppc_stub_long_branch_r2off;
12124                     }
12125
12126                   if (stub_type == ppc_stub_none)
12127                     continue;
12128
12129                   /* __tls_get_addr calls might be eliminated.  */
12130                   if (stub_type != ppc_stub_plt_call
12131                       && hash != NULL
12132                       && (hash == htab->tls_get_addr
12133                           || hash == htab->tls_get_addr_fd)
12134                       && section->has_tls_reloc
12135                       && irela != internal_relocs)
12136                     {
12137                       /* Get tls info.  */
12138                       unsigned char *tls_mask;
12139
12140                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12141                                          irela - 1, input_bfd))
12142                         goto error_ret_free_internal;
12143                       if (*tls_mask != 0)
12144                         continue;
12145                     }
12146
12147                   if (stub_type == ppc_stub_plt_call
12148                       && irela + 1 < irelaend
12149                       && irela[1].r_offset == irela->r_offset + 4
12150                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12151                     {
12152                       if (!tocsave_find (htab, INSERT,
12153                                          &local_syms, irela + 1, input_bfd))
12154                         goto error_ret_free_internal;
12155                     }
12156                   else if (stub_type == ppc_stub_plt_call)
12157                     stub_type = ppc_stub_plt_call_r2save;
12158
12159                   /* Support for grouping stub sections.  */
12160                   id_sec = htab->stub_group[section->id].link_sec;
12161
12162                   /* Get the name of this stub.  */
12163                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12164                   if (!stub_name)
12165                     goto error_ret_free_internal;
12166
12167                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12168                                                      stub_name, FALSE, FALSE);
12169                   if (stub_entry != NULL)
12170                     {
12171                       /* The proper stub has already been created.  */
12172                       free (stub_name);
12173                       if (stub_type == ppc_stub_plt_call_r2save)
12174                         stub_entry->stub_type = stub_type;
12175                       continue;
12176                     }
12177
12178                   stub_entry = ppc_add_stub (stub_name, section, info);
12179                   if (stub_entry == NULL)
12180                     {
12181                       free (stub_name);
12182                     error_ret_free_internal:
12183                       if (elf_section_data (section)->relocs == NULL)
12184                         free (internal_relocs);
12185                     error_ret_free_local:
12186                       if (local_syms != NULL
12187                           && (symtab_hdr->contents
12188                               != (unsigned char *) local_syms))
12189                         free (local_syms);
12190                       return FALSE;
12191                     }
12192
12193                   stub_entry->stub_type = stub_type;
12194                   if (stub_type != ppc_stub_plt_call
12195                       && stub_type != ppc_stub_plt_call_r2save)
12196                     {
12197                       stub_entry->target_value = code_value;
12198                       stub_entry->target_section = code_sec;
12199                     }
12200                   else
12201                     {
12202                       stub_entry->target_value = sym_value;
12203                       stub_entry->target_section = sym_sec;
12204                     }
12205                   stub_entry->h = hash;
12206                   stub_entry->plt_ent = plt_ent;
12207                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12208
12209                   if (stub_entry->h != NULL)
12210                     htab->stub_globals += 1;
12211                 }
12212
12213               /* We're done with the internal relocs, free them.  */
12214               if (elf_section_data (section)->relocs != internal_relocs)
12215                 free (internal_relocs);
12216             }
12217
12218           if (local_syms != NULL
12219               && symtab_hdr->contents != (unsigned char *) local_syms)
12220             {
12221               if (!info->keep_memory)
12222                 free (local_syms);
12223               else
12224                 symtab_hdr->contents = (unsigned char *) local_syms;
12225             }
12226         }
12227
12228       /* We may have added some stubs.  Find out the new size of the
12229          stub sections.  */
12230       for (stub_sec = htab->params->stub_bfd->sections;
12231            stub_sec != NULL;
12232            stub_sec = stub_sec->next)
12233         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12234           {
12235             stub_sec->rawsize = stub_sec->size;
12236             stub_sec->size = 0;
12237             stub_sec->reloc_count = 0;
12238             stub_sec->flags &= ~SEC_RELOC;
12239           }
12240
12241       htab->brlt->size = 0;
12242       htab->brlt->reloc_count = 0;
12243       htab->brlt->flags &= ~SEC_RELOC;
12244       if (htab->relbrlt != NULL)
12245         htab->relbrlt->size = 0;
12246
12247       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12248
12249       if (info->emitrelocations
12250           && htab->glink != NULL && htab->glink->size != 0)
12251         {
12252           htab->glink->reloc_count = 1;
12253           htab->glink->flags |= SEC_RELOC;
12254         }
12255
12256       if (htab->glink_eh_frame != NULL
12257           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12258           && htab->glink_eh_frame->output_section->size != 0)
12259         {
12260           size_t size = 0, align;
12261
12262           for (stub_sec = htab->params->stub_bfd->sections;
12263                stub_sec != NULL;
12264                stub_sec = stub_sec->next)
12265             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12266               size += 20;
12267           if (htab->glink != NULL && htab->glink->size != 0)
12268             size += 24;
12269           if (size != 0)
12270             size += sizeof (glink_eh_frame_cie);
12271           align = 1;
12272           align <<= htab->glink_eh_frame->output_section->alignment_power;
12273           align -= 1;
12274           size = (size + align) & ~align;
12275           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12276           htab->glink_eh_frame->size = size;
12277         }
12278
12279       if (htab->params->plt_stub_align != 0)
12280         for (stub_sec = htab->params->stub_bfd->sections;
12281              stub_sec != NULL;
12282              stub_sec = stub_sec->next)
12283           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12284             stub_sec->size = ((stub_sec->size
12285                                + (1 << htab->params->plt_stub_align) - 1)
12286                               & (-1 << htab->params->plt_stub_align));
12287
12288       for (stub_sec = htab->params->stub_bfd->sections;
12289            stub_sec != NULL;
12290            stub_sec = stub_sec->next)
12291         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12292             && stub_sec->rawsize != stub_sec->size)
12293           break;
12294
12295       /* Exit from this loop when no stubs have been added, and no stubs
12296          have changed size.  */
12297       if (stub_sec == NULL
12298           && (htab->glink_eh_frame == NULL
12299               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12300         break;
12301
12302       /* Ask the linker to do its stuff.  */
12303       (*htab->params->layout_sections_again) ();
12304     }
12305
12306   maybe_strip_output (info, htab->brlt);
12307   if (htab->glink_eh_frame != NULL)
12308     maybe_strip_output (info, htab->glink_eh_frame);
12309
12310   return TRUE;
12311 }
12312
12313 /* Called after we have determined section placement.  If sections
12314    move, we'll be called again.  Provide a value for TOCstart.  */
12315
12316 bfd_vma
12317 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12318 {
12319   asection *s;
12320   bfd_vma TOCstart;
12321
12322   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12323      order.  The TOC starts where the first of these sections starts.  */
12324   s = bfd_get_section_by_name (obfd, ".got");
12325   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12326     s = bfd_get_section_by_name (obfd, ".toc");
12327   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12328     s = bfd_get_section_by_name (obfd, ".tocbss");
12329   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12330     s = bfd_get_section_by_name (obfd, ".plt");
12331   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12332     {
12333       /* This may happen for
12334          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12335          .toc directive
12336          o  bad linker script
12337          o --gc-sections and empty TOC sections
12338
12339          FIXME: Warn user?  */
12340
12341       /* Look for a likely section.  We probably won't even be
12342          using TOCstart.  */
12343       for (s = obfd->sections; s != NULL; s = s->next)
12344         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12345                          | SEC_EXCLUDE))
12346             == (SEC_ALLOC | SEC_SMALL_DATA))
12347           break;
12348       if (s == NULL)
12349         for (s = obfd->sections; s != NULL; s = s->next)
12350           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12351               == (SEC_ALLOC | SEC_SMALL_DATA))
12352             break;
12353       if (s == NULL)
12354         for (s = obfd->sections; s != NULL; s = s->next)
12355           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12356               == SEC_ALLOC)
12357             break;
12358       if (s == NULL)
12359         for (s = obfd->sections; s != NULL; s = s->next)
12360           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12361             break;
12362     }
12363
12364   TOCstart = 0;
12365   if (s != NULL)
12366     TOCstart = s->output_section->vma + s->output_offset;
12367
12368   _bfd_set_gp_value (obfd, TOCstart);
12369
12370   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12371     {
12372       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12373
12374       if (htab != NULL
12375           && htab->elf.hgot != NULL)
12376         {
12377           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12378           htab->elf.hgot->root.u.def.section = s;
12379         }
12380     }
12381   return TOCstart;
12382 }
12383
12384 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12385    write out any global entry stubs.  */
12386
12387 static bfd_boolean
12388 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12389 {
12390   struct bfd_link_info *info;
12391   struct ppc_link_hash_table *htab;
12392   struct plt_entry *pent;
12393   asection *s;
12394
12395   if (h->root.type == bfd_link_hash_indirect)
12396     return TRUE;
12397
12398   if (!h->pointer_equality_needed)
12399     return TRUE;
12400
12401   if (h->def_regular)
12402     return TRUE;
12403
12404   info = inf;
12405   htab = ppc_hash_table (info);
12406   if (htab == NULL)
12407     return FALSE;
12408
12409   s = htab->glink;
12410   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12411     if (pent->plt.offset != (bfd_vma) -1
12412         && pent->addend == 0)
12413       {
12414         bfd_byte *p;
12415         asection *plt;
12416         bfd_vma off;
12417
12418         p = s->contents + h->root.u.def.value;
12419         plt = htab->elf.splt;
12420         if (!htab->elf.dynamic_sections_created
12421             || h->dynindx == -1)
12422           plt = htab->elf.iplt;
12423         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12424         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12425
12426         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12427           {
12428             info->callbacks->einfo
12429               (_("%P: linkage table error against `%T'\n"),
12430                h->root.root.string);
12431             bfd_set_error (bfd_error_bad_value);
12432             htab->stub_error = TRUE;
12433           }
12434
12435         if (PPC_HA (off) != 0)
12436           {
12437             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12438             p += 4;
12439           }
12440         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12441         p += 4;
12442         bfd_put_32 (s->owner, MTCTR_R12, p);
12443         p += 4;
12444         bfd_put_32 (s->owner, BCTR, p);
12445         break;
12446       }
12447   return TRUE;
12448 }
12449
12450 /* Build all the stubs associated with the current output file.
12451    The stubs are kept in a hash table attached to the main linker
12452    hash table.  This function is called via gldelf64ppc_finish.  */
12453
12454 bfd_boolean
12455 ppc64_elf_build_stubs (struct bfd_link_info *info,
12456                        char **stats)
12457 {
12458   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12459   asection *stub_sec;
12460   bfd_byte *p;
12461   int stub_sec_count = 0;
12462
12463   if (htab == NULL)
12464     return FALSE;
12465
12466   /* Allocate memory to hold the linker stubs.  */
12467   for (stub_sec = htab->params->stub_bfd->sections;
12468        stub_sec != NULL;
12469        stub_sec = stub_sec->next)
12470     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12471         && stub_sec->size != 0)
12472       {
12473         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12474         if (stub_sec->contents == NULL)
12475           return FALSE;
12476         /* We want to check that built size is the same as calculated
12477            size.  rawsize is a convenient location to use.  */
12478         stub_sec->rawsize = stub_sec->size;
12479         stub_sec->size = 0;
12480       }
12481
12482   if (htab->glink != NULL && htab->glink->size != 0)
12483     {
12484       unsigned int indx;
12485       bfd_vma plt0;
12486
12487       /* Build the .glink plt call stub.  */
12488       if (htab->params->emit_stub_syms)
12489         {
12490           struct elf_link_hash_entry *h;
12491           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12492                                     TRUE, FALSE, FALSE);
12493           if (h == NULL)
12494             return FALSE;
12495           if (h->root.type == bfd_link_hash_new)
12496             {
12497               h->root.type = bfd_link_hash_defined;
12498               h->root.u.def.section = htab->glink;
12499               h->root.u.def.value = 8;
12500               h->ref_regular = 1;
12501               h->def_regular = 1;
12502               h->ref_regular_nonweak = 1;
12503               h->forced_local = 1;
12504               h->non_elf = 0;
12505             }
12506         }
12507       plt0 = (htab->elf.splt->output_section->vma
12508               + htab->elf.splt->output_offset
12509               - 16);
12510       if (info->emitrelocations)
12511         {
12512           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12513           if (r == NULL)
12514             return FALSE;
12515           r->r_offset = (htab->glink->output_offset
12516                          + htab->glink->output_section->vma);
12517           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12518           r->r_addend = plt0;
12519         }
12520       p = htab->glink->contents;
12521       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12522       bfd_put_64 (htab->glink->owner, plt0, p);
12523       p += 8;
12524       if (htab->opd_abi)
12525         {
12526           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12527           p += 4;
12528           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12529           p += 4;
12530           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12531           p += 4;
12532           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12533           p += 4;
12534           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12535           p += 4;
12536           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12537           p += 4;
12538           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12539           p += 4;
12540           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12541           p += 4;
12542           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12543           p += 4;
12544           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12545           p += 4;
12546         }
12547       else
12548         {
12549           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12550           p += 4;
12551           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12552           p += 4;
12553           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12554           p += 4;
12555           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12556           p += 4;
12557           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12558           p += 4;
12559           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12560           p += 4;
12561           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12562           p += 4;
12563           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), 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, SRDI_R0_R0_2, 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 | 8, p);
12572           p += 4;
12573         }
12574       bfd_put_32 (htab->glink->owner, BCTR, p);
12575       p += 4;
12576       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12577         {
12578           bfd_put_32 (htab->glink->owner, NOP, p);
12579           p += 4;
12580         }
12581
12582       /* Build the .glink lazy link call stubs.  */
12583       indx = 0;
12584       while (p < htab->glink->contents + htab->glink->rawsize)
12585         {
12586           if (htab->opd_abi)
12587             {
12588               if (indx < 0x8000)
12589                 {
12590                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12591                   p += 4;
12592                 }
12593               else
12594                 {
12595                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12596                   p += 4;
12597                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12598                               p);
12599                   p += 4;
12600                 }
12601             }
12602           bfd_put_32 (htab->glink->owner,
12603                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12604           indx++;
12605           p += 4;
12606         }
12607
12608       /* Build .glink global entry stubs.  */
12609       if (htab->glink->size > htab->glink->rawsize)
12610         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12611     }
12612
12613   if (htab->brlt->size != 0)
12614     {
12615       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12616                                          htab->brlt->size);
12617       if (htab->brlt->contents == NULL)
12618         return FALSE;
12619     }
12620   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12621     {
12622       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12623                                             htab->relbrlt->size);
12624       if (htab->relbrlt->contents == NULL)
12625         return FALSE;
12626     }
12627
12628   if (htab->glink_eh_frame != NULL
12629       && htab->glink_eh_frame->size != 0)
12630     {
12631       bfd_vma val;
12632       bfd_byte *last_fde;
12633       size_t last_fde_len, size, align, pad;
12634
12635       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12636       if (p == NULL)
12637         return FALSE;
12638       htab->glink_eh_frame->contents = p;
12639       last_fde = p;
12640
12641       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12642
12643       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12644       /* CIE length (rewrite in case little-endian).  */
12645       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12646       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12647       p += sizeof (glink_eh_frame_cie);
12648
12649       for (stub_sec = htab->params->stub_bfd->sections;
12650            stub_sec != NULL;
12651            stub_sec = stub_sec->next)
12652         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12653           {
12654             last_fde = p;
12655             last_fde_len = 16;
12656             /* FDE length.  */
12657             bfd_put_32 (htab->elf.dynobj, 16, p);
12658             p += 4;
12659             /* CIE pointer.  */
12660             val = p - htab->glink_eh_frame->contents;
12661             bfd_put_32 (htab->elf.dynobj, val, p);
12662             p += 4;
12663             /* Offset to stub section.  */
12664             val = (stub_sec->output_section->vma
12665                    + stub_sec->output_offset);
12666             val -= (htab->glink_eh_frame->output_section->vma
12667                     + htab->glink_eh_frame->output_offset);
12668             val -= p - htab->glink_eh_frame->contents;
12669             if (val + 0x80000000 > 0xffffffff)
12670               {
12671                 info->callbacks->einfo
12672                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12673                    stub_sec->name);
12674                 return FALSE;
12675               }
12676             bfd_put_32 (htab->elf.dynobj, val, p);
12677             p += 4;
12678             /* stub section size.  */
12679             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12680             p += 4;
12681             /* Augmentation.  */
12682             p += 1;
12683             /* Pad.  */
12684             p += 3;
12685           }
12686       if (htab->glink != NULL && htab->glink->size != 0)
12687         {
12688           last_fde = p;
12689           last_fde_len = 20;
12690           /* FDE length.  */
12691           bfd_put_32 (htab->elf.dynobj, 20, p);
12692           p += 4;
12693           /* CIE pointer.  */
12694           val = p - htab->glink_eh_frame->contents;
12695           bfd_put_32 (htab->elf.dynobj, val, p);
12696           p += 4;
12697           /* Offset to .glink.  */
12698           val = (htab->glink->output_section->vma
12699                  + htab->glink->output_offset
12700                  + 8);
12701           val -= (htab->glink_eh_frame->output_section->vma
12702                   + htab->glink_eh_frame->output_offset);
12703           val -= p - htab->glink_eh_frame->contents;
12704           if (val + 0x80000000 > 0xffffffff)
12705             {
12706               info->callbacks->einfo
12707                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12708                  htab->glink->name);
12709               return FALSE;
12710             }
12711           bfd_put_32 (htab->elf.dynobj, val, p);
12712           p += 4;
12713           /* .glink size.  */
12714           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12715           p += 4;
12716           /* Augmentation.  */
12717           p += 1;
12718
12719           *p++ = DW_CFA_advance_loc + 1;
12720           *p++ = DW_CFA_register;
12721           *p++ = 65;
12722           *p++ = 12;
12723           *p++ = DW_CFA_advance_loc + 4;
12724           *p++ = DW_CFA_restore_extended;
12725           *p++ = 65;
12726         }
12727       /* Subsume any padding into the last FDE if user .eh_frame
12728          sections are aligned more than glink_eh_frame.  Otherwise any
12729          zero padding will be seen as a terminator.  */
12730       size = p - htab->glink_eh_frame->contents;
12731       align = 1;
12732       align <<= htab->glink_eh_frame->output_section->alignment_power;
12733       align -= 1;
12734       pad = ((size + align) & ~align) - size;
12735       htab->glink_eh_frame->size = size + pad;
12736       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12737     }
12738
12739   /* Build the stubs as directed by the stub hash table.  */
12740   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12741
12742   if (htab->relbrlt != NULL)
12743     htab->relbrlt->reloc_count = 0;
12744
12745   if (htab->params->plt_stub_align != 0)
12746     for (stub_sec = htab->params->stub_bfd->sections;
12747          stub_sec != NULL;
12748          stub_sec = stub_sec->next)
12749       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12750         stub_sec->size = ((stub_sec->size
12751                            + (1 << htab->params->plt_stub_align) - 1)
12752                           & (-1 << htab->params->plt_stub_align));
12753
12754   for (stub_sec = htab->params->stub_bfd->sections;
12755        stub_sec != NULL;
12756        stub_sec = stub_sec->next)
12757     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12758       {
12759         stub_sec_count += 1;
12760         if (stub_sec->rawsize != stub_sec->size)
12761           break;
12762       }
12763
12764   if (stub_sec != NULL
12765       || (htab->glink_eh_frame != NULL
12766           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12767     {
12768       htab->stub_error = TRUE;
12769       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12770     }
12771
12772   if (htab->stub_error)
12773     return FALSE;
12774
12775   if (stats != NULL)
12776     {
12777       *stats = bfd_malloc (500);
12778       if (*stats == NULL)
12779         return FALSE;
12780
12781       sprintf (*stats, _("linker stubs in %u group%s\n"
12782                          "  branch       %lu\n"
12783                          "  toc adjust   %lu\n"
12784                          "  long branch  %lu\n"
12785                          "  long toc adj %lu\n"
12786                          "  plt call     %lu\n"
12787                          "  plt call toc %lu"),
12788                stub_sec_count,
12789                stub_sec_count == 1 ? "" : "s",
12790                htab->stub_count[ppc_stub_long_branch - 1],
12791                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12792                htab->stub_count[ppc_stub_plt_branch - 1],
12793                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12794                htab->stub_count[ppc_stub_plt_call - 1],
12795                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12796     }
12797   return TRUE;
12798 }
12799
12800 /* This function undoes the changes made by add_symbol_adjust.  */
12801
12802 static bfd_boolean
12803 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12804 {
12805   struct ppc_link_hash_entry *eh;
12806
12807   if (h->root.type == bfd_link_hash_indirect)
12808     return TRUE;
12809
12810   eh = (struct ppc_link_hash_entry *) h;
12811   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12812     return TRUE;
12813
12814   eh->elf.root.type = bfd_link_hash_undefined;
12815   return TRUE;
12816 }
12817
12818 void
12819 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12820 {
12821   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12822
12823   if (htab != NULL)
12824     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12825 }
12826
12827 /* What to do when ld finds relocations against symbols defined in
12828    discarded sections.  */
12829
12830 static unsigned int
12831 ppc64_elf_action_discarded (asection *sec)
12832 {
12833   if (strcmp (".opd", sec->name) == 0)
12834     return 0;
12835
12836   if (strcmp (".toc", sec->name) == 0)
12837     return 0;
12838
12839   if (strcmp (".toc1", sec->name) == 0)
12840     return 0;
12841
12842   return _bfd_elf_default_action_discarded (sec);
12843 }
12844
12845 /* The RELOCATE_SECTION function is called by the ELF backend linker
12846    to handle the relocations for a section.
12847
12848    The relocs are always passed as Rela structures; if the section
12849    actually uses Rel structures, the r_addend field will always be
12850    zero.
12851
12852    This function is responsible for adjust the section contents as
12853    necessary, and (if using Rela relocs and generating a
12854    relocatable output file) adjusting the reloc addend as
12855    necessary.
12856
12857    This function does not have to worry about setting the reloc
12858    address or the reloc symbol index.
12859
12860    LOCAL_SYMS is a pointer to the swapped in local symbols.
12861
12862    LOCAL_SECTIONS is an array giving the section in the input file
12863    corresponding to the st_shndx field of each local symbol.
12864
12865    The global hash table entry for the global symbols can be found
12866    via elf_sym_hashes (input_bfd).
12867
12868    When generating relocatable output, this function must handle
12869    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12870    going to be the section symbol corresponding to the output
12871    section, which means that the addend must be adjusted
12872    accordingly.  */
12873
12874 static bfd_boolean
12875 ppc64_elf_relocate_section (bfd *output_bfd,
12876                             struct bfd_link_info *info,
12877                             bfd *input_bfd,
12878                             asection *input_section,
12879                             bfd_byte *contents,
12880                             Elf_Internal_Rela *relocs,
12881                             Elf_Internal_Sym *local_syms,
12882                             asection **local_sections)
12883 {
12884   struct ppc_link_hash_table *htab;
12885   Elf_Internal_Shdr *symtab_hdr;
12886   struct elf_link_hash_entry **sym_hashes;
12887   Elf_Internal_Rela *rel;
12888   Elf_Internal_Rela *relend;
12889   Elf_Internal_Rela outrel;
12890   bfd_byte *loc;
12891   struct got_entry **local_got_ents;
12892   bfd_vma TOCstart;
12893   bfd_boolean ret = TRUE;
12894   bfd_boolean is_opd;
12895   /* Assume 'at' branch hints.  */
12896   bfd_boolean is_isa_v2 = TRUE;
12897   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12898
12899   /* Initialize howto table if needed.  */
12900   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12901     ppc_howto_init ();
12902
12903   htab = ppc_hash_table (info);
12904   if (htab == NULL)
12905     return FALSE;
12906
12907   /* Don't relocate stub sections.  */
12908   if (input_section->owner == htab->params->stub_bfd)
12909     return TRUE;
12910
12911   BFD_ASSERT (is_ppc64_elf (input_bfd));
12912
12913   local_got_ents = elf_local_got_ents (input_bfd);
12914   TOCstart = elf_gp (output_bfd);
12915   symtab_hdr = &elf_symtab_hdr (input_bfd);
12916   sym_hashes = elf_sym_hashes (input_bfd);
12917   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12918
12919   rel = relocs;
12920   relend = relocs + input_section->reloc_count;
12921   for (; rel < relend; rel++)
12922     {
12923       enum elf_ppc64_reloc_type r_type;
12924       bfd_vma addend;
12925       bfd_reloc_status_type r;
12926       Elf_Internal_Sym *sym;
12927       asection *sec;
12928       struct elf_link_hash_entry *h_elf;
12929       struct ppc_link_hash_entry *h;
12930       struct ppc_link_hash_entry *fdh;
12931       const char *sym_name;
12932       unsigned long r_symndx, toc_symndx;
12933       bfd_vma toc_addend;
12934       unsigned char tls_mask, tls_gd, tls_type;
12935       unsigned char sym_type;
12936       bfd_vma relocation;
12937       bfd_boolean unresolved_reloc;
12938       bfd_boolean warned;
12939       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12940       unsigned int insn;
12941       unsigned int mask;
12942       struct ppc_stub_hash_entry *stub_entry;
12943       bfd_vma max_br_offset;
12944       bfd_vma from;
12945       const Elf_Internal_Rela orig_rel = *rel;
12946
12947       r_type = ELF64_R_TYPE (rel->r_info);
12948       r_symndx = ELF64_R_SYM (rel->r_info);
12949
12950       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12951          symbol of the previous ADDR64 reloc.  The symbol gives us the
12952          proper TOC base to use.  */
12953       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12954           && rel != relocs
12955           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12956           && is_opd)
12957         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12958
12959       sym = NULL;
12960       sec = NULL;
12961       h_elf = NULL;
12962       sym_name = NULL;
12963       unresolved_reloc = FALSE;
12964       warned = FALSE;
12965
12966       if (r_symndx < symtab_hdr->sh_info)
12967         {
12968           /* It's a local symbol.  */
12969           struct _opd_sec_data *opd;
12970
12971           sym = local_syms + r_symndx;
12972           sec = local_sections[r_symndx];
12973           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12974           sym_type = ELF64_ST_TYPE (sym->st_info);
12975           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12976           opd = get_opd_info (sec);
12977           if (opd != NULL && opd->adjust != NULL)
12978             {
12979               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12980               if (adjust == -1)
12981                 relocation = 0;
12982               else
12983                 {
12984                   /* If this is a relocation against the opd section sym
12985                      and we have edited .opd, adjust the reloc addend so
12986                      that ld -r and ld --emit-relocs output is correct.
12987                      If it is a reloc against some other .opd symbol,
12988                      then the symbol value will be adjusted later.  */
12989                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12990                     rel->r_addend += adjust;
12991                   else
12992                     relocation += adjust;
12993                 }
12994             }
12995         }
12996       else
12997         {
12998           bfd_boolean ignored;
12999
13000           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13001                                    r_symndx, symtab_hdr, sym_hashes,
13002                                    h_elf, sec, relocation,
13003                                    unresolved_reloc, warned, ignored);
13004           sym_name = h_elf->root.root.string;
13005           sym_type = h_elf->type;
13006           if (sec != NULL
13007               && sec->owner == output_bfd
13008               && strcmp (sec->name, ".opd") == 0)
13009             {
13010               /* This is a symbol defined in a linker script.  All
13011                  such are defined in output sections, even those
13012                  defined by simple assignment from a symbol defined in
13013                  an input section.  Transfer the symbol to an
13014                  appropriate input .opd section, so that a branch to
13015                  this symbol will be mapped to the location specified
13016                  by the opd entry.  */
13017               struct bfd_link_order *lo;
13018               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13019                 if (lo->type == bfd_indirect_link_order)
13020                   {
13021                     asection *isec = lo->u.indirect.section;
13022                     if (h_elf->root.u.def.value >= isec->output_offset
13023                         && h_elf->root.u.def.value < (isec->output_offset
13024                                                       + isec->size))
13025                       {
13026                         h_elf->root.u.def.value -= isec->output_offset;
13027                         h_elf->root.u.def.section = isec;
13028                         sec = isec;
13029                         break;
13030                       }
13031                   }
13032             }
13033         }
13034       h = (struct ppc_link_hash_entry *) h_elf;
13035
13036       if (sec != NULL && discarded_section (sec))
13037         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13038                                          rel, 1, relend,
13039                                          ppc64_elf_howto_table[r_type], 0,
13040                                          contents);
13041
13042       if (info->relocatable)
13043         continue;
13044
13045       if (h != NULL && &h->elf == htab->elf.hgot)
13046         {
13047           relocation = (TOCstart
13048                         + htab->stub_group[input_section->id].toc_off);
13049           sec = bfd_abs_section_ptr;
13050           unresolved_reloc = FALSE;
13051         }
13052
13053       /* TLS optimizations.  Replace instruction sequences and relocs
13054          based on information we collected in tls_optimize.  We edit
13055          RELOCS so that --emit-relocs will output something sensible
13056          for the final instruction stream.  */
13057       tls_mask = 0;
13058       tls_gd = 0;
13059       toc_symndx = 0;
13060       if (h != NULL)
13061         tls_mask = h->tls_mask;
13062       else if (local_got_ents != NULL)
13063         {
13064           struct plt_entry **local_plt = (struct plt_entry **)
13065             (local_got_ents + symtab_hdr->sh_info);
13066           unsigned char *lgot_masks = (unsigned char *)
13067             (local_plt + symtab_hdr->sh_info);
13068           tls_mask = lgot_masks[r_symndx];
13069         }
13070       if (tls_mask == 0
13071           && (r_type == R_PPC64_TLS
13072               || r_type == R_PPC64_TLSGD
13073               || r_type == R_PPC64_TLSLD))
13074         {
13075           /* Check for toc tls entries.  */
13076           unsigned char *toc_tls;
13077
13078           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13079                              &local_syms, rel, input_bfd))
13080             return FALSE;
13081
13082           if (toc_tls)
13083             tls_mask = *toc_tls;
13084         }
13085
13086       /* Check that tls relocs are used with tls syms, and non-tls
13087          relocs are used with non-tls syms.  */
13088       if (r_symndx != STN_UNDEF
13089           && r_type != R_PPC64_NONE
13090           && (h == NULL
13091               || h->elf.root.type == bfd_link_hash_defined
13092               || h->elf.root.type == bfd_link_hash_defweak)
13093           && (IS_PPC64_TLS_RELOC (r_type)
13094               != (sym_type == STT_TLS
13095                   || (sym_type == STT_SECTION
13096                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13097         {
13098           if (tls_mask != 0
13099               && (r_type == R_PPC64_TLS
13100                   || r_type == R_PPC64_TLSGD
13101                   || r_type == R_PPC64_TLSLD))
13102             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13103             ;
13104           else
13105             info->callbacks->einfo
13106               (!IS_PPC64_TLS_RELOC (r_type)
13107                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13108                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13109                input_bfd, input_section, rel->r_offset,
13110                ppc64_elf_howto_table[r_type]->name,
13111                sym_name);
13112         }
13113
13114       /* Ensure reloc mapping code below stays sane.  */
13115       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13116           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13117           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13118           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13119           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13120           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13121           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13122           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13123           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13124           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13125         abort ();
13126
13127       switch (r_type)
13128         {
13129         default:
13130           break;
13131
13132         case R_PPC64_LO_DS_OPT:
13133           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13134           if ((insn & (0x3f << 26)) != 58u << 26)
13135             abort ();
13136           insn += (14u << 26) - (58u << 26);
13137           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13138           r_type = R_PPC64_TOC16_LO;
13139           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13140           break;
13141
13142         case R_PPC64_TOC16:
13143         case R_PPC64_TOC16_LO:
13144         case R_PPC64_TOC16_DS:
13145         case R_PPC64_TOC16_LO_DS:
13146           {
13147             /* Check for toc tls entries.  */
13148             unsigned char *toc_tls;
13149             int retval;
13150
13151             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13152                                    &local_syms, rel, input_bfd);
13153             if (retval == 0)
13154               return FALSE;
13155
13156             if (toc_tls)
13157               {
13158                 tls_mask = *toc_tls;
13159                 if (r_type == R_PPC64_TOC16_DS
13160                     || r_type == R_PPC64_TOC16_LO_DS)
13161                   {
13162                     if (tls_mask != 0
13163                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13164                       goto toctprel;
13165                   }
13166                 else
13167                   {
13168                     /* If we found a GD reloc pair, then we might be
13169                        doing a GD->IE transition.  */
13170                     if (retval == 2)
13171                       {
13172                         tls_gd = TLS_TPRELGD;
13173                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13174                           goto tls_ldgd_opt;
13175                       }
13176                     else if (retval == 3)
13177                       {
13178                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13179                           goto tls_ldgd_opt;
13180                       }
13181                   }
13182               }
13183           }
13184           break;
13185
13186         case R_PPC64_GOT_TPREL16_HI:
13187         case R_PPC64_GOT_TPREL16_HA:
13188           if (tls_mask != 0
13189               && (tls_mask & TLS_TPREL) == 0)
13190             {
13191               rel->r_offset -= d_offset;
13192               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13193               r_type = R_PPC64_NONE;
13194               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13195             }
13196           break;
13197
13198         case R_PPC64_GOT_TPREL16_DS:
13199         case R_PPC64_GOT_TPREL16_LO_DS:
13200           if (tls_mask != 0
13201               && (tls_mask & TLS_TPREL) == 0)
13202             {
13203             toctprel:
13204               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13205               insn &= 31 << 21;
13206               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13207               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13208               r_type = R_PPC64_TPREL16_HA;
13209               if (toc_symndx != 0)
13210                 {
13211                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13212                   rel->r_addend = toc_addend;
13213                   /* We changed the symbol.  Start over in order to
13214                      get h, sym, sec etc. right.  */
13215                   rel--;
13216                   continue;
13217                 }
13218               else
13219                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13220             }
13221           break;
13222
13223         case R_PPC64_TLS:
13224           if (tls_mask != 0
13225               && (tls_mask & TLS_TPREL) == 0)
13226             {
13227               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13228               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13229               if (insn == 0)
13230                 abort ();
13231               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13232               /* Was PPC64_TLS which sits on insn boundary, now
13233                  PPC64_TPREL16_LO which is at low-order half-word.  */
13234               rel->r_offset += d_offset;
13235               r_type = R_PPC64_TPREL16_LO;
13236               if (toc_symndx != 0)
13237                 {
13238                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13239                   rel->r_addend = toc_addend;
13240                   /* We changed the symbol.  Start over in order to
13241                      get h, sym, sec etc. right.  */
13242                   rel--;
13243                   continue;
13244                 }
13245               else
13246                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13247             }
13248           break;
13249
13250         case R_PPC64_GOT_TLSGD16_HI:
13251         case R_PPC64_GOT_TLSGD16_HA:
13252           tls_gd = TLS_TPRELGD;
13253           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13254             goto tls_gdld_hi;
13255           break;
13256
13257         case R_PPC64_GOT_TLSLD16_HI:
13258         case R_PPC64_GOT_TLSLD16_HA:
13259           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13260             {
13261             tls_gdld_hi:
13262               if ((tls_mask & tls_gd) != 0)
13263                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13264                           + R_PPC64_GOT_TPREL16_DS);
13265               else
13266                 {
13267                   rel->r_offset -= d_offset;
13268                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13269                   r_type = R_PPC64_NONE;
13270                 }
13271               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13272             }
13273           break;
13274
13275         case R_PPC64_GOT_TLSGD16:
13276         case R_PPC64_GOT_TLSGD16_LO:
13277           tls_gd = TLS_TPRELGD;
13278           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13279             goto tls_ldgd_opt;
13280           break;
13281
13282         case R_PPC64_GOT_TLSLD16:
13283         case R_PPC64_GOT_TLSLD16_LO:
13284           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13285             {
13286               unsigned int insn1, insn2, insn3;
13287               bfd_vma offset;
13288
13289             tls_ldgd_opt:
13290               offset = (bfd_vma) -1;
13291               /* If not using the newer R_PPC64_TLSGD/LD to mark
13292                  __tls_get_addr calls, we must trust that the call
13293                  stays with its arg setup insns, ie. that the next
13294                  reloc is the __tls_get_addr call associated with
13295                  the current reloc.  Edit both insns.  */
13296               if (input_section->has_tls_get_addr_call
13297                   && rel + 1 < relend
13298                   && branch_reloc_hash_match (input_bfd, rel + 1,
13299                                               htab->tls_get_addr,
13300                                               htab->tls_get_addr_fd))
13301                 offset = rel[1].r_offset;
13302               if ((tls_mask & tls_gd) != 0)
13303                 {
13304                   /* IE */
13305                   insn1 = bfd_get_32 (output_bfd,
13306                                       contents + rel->r_offset - d_offset);
13307                   insn1 &= (1 << 26) - (1 << 2);
13308                   insn1 |= 58 << 26;    /* ld */
13309                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13310                   if (offset != (bfd_vma) -1)
13311                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13312                   if ((tls_mask & TLS_EXPLICIT) == 0)
13313                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13314                               + R_PPC64_GOT_TPREL16_DS);
13315                   else
13316                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13317                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13318                 }
13319               else
13320                 {
13321                   /* LE */
13322                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13323                   insn2 = 0x38630000;   /* addi 3,3,0 */
13324                   if (tls_gd == 0)
13325                     {
13326                       /* Was an LD reloc.  */
13327                       if (toc_symndx)
13328                         sec = local_sections[toc_symndx];
13329                       for (r_symndx = 0;
13330                            r_symndx < symtab_hdr->sh_info;
13331                            r_symndx++)
13332                         if (local_sections[r_symndx] == sec)
13333                           break;
13334                       if (r_symndx >= symtab_hdr->sh_info)
13335                         r_symndx = STN_UNDEF;
13336                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13337                       if (r_symndx != STN_UNDEF)
13338                         rel->r_addend -= (local_syms[r_symndx].st_value
13339                                           + sec->output_offset
13340                                           + sec->output_section->vma);
13341                     }
13342                   else if (toc_symndx != 0)
13343                     {
13344                       r_symndx = toc_symndx;
13345                       rel->r_addend = toc_addend;
13346                     }
13347                   r_type = R_PPC64_TPREL16_HA;
13348                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13349                   if (offset != (bfd_vma) -1)
13350                     {
13351                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13352                                                     R_PPC64_TPREL16_LO);
13353                       rel[1].r_offset = offset + d_offset;
13354                       rel[1].r_addend = rel->r_addend;
13355                     }
13356                 }
13357               bfd_put_32 (output_bfd, insn1,
13358                           contents + rel->r_offset - d_offset);
13359               if (offset != (bfd_vma) -1)
13360                 {
13361                   insn3 = bfd_get_32 (output_bfd,
13362                                       contents + offset + 4);
13363                   if (insn3 == NOP
13364                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13365                     {
13366                       rel[1].r_offset += 4;
13367                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13368                       insn2 = NOP;
13369                     }
13370                   bfd_put_32 (output_bfd, insn2, contents + offset);
13371                 }
13372               if ((tls_mask & tls_gd) == 0
13373                   && (tls_gd == 0 || toc_symndx != 0))
13374                 {
13375                   /* We changed the symbol.  Start over in order
13376                      to get h, sym, sec etc. right.  */
13377                   rel--;
13378                   continue;
13379                 }
13380             }
13381           break;
13382
13383         case R_PPC64_TLSGD:
13384           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13385             {
13386               unsigned int insn2, insn3;
13387               bfd_vma offset = rel->r_offset;
13388
13389               if ((tls_mask & TLS_TPRELGD) != 0)
13390                 {
13391                   /* IE */
13392                   r_type = R_PPC64_NONE;
13393                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13394                 }
13395               else
13396                 {
13397                   /* LE */
13398                   if (toc_symndx != 0)
13399                     {
13400                       r_symndx = toc_symndx;
13401                       rel->r_addend = toc_addend;
13402                     }
13403                   r_type = R_PPC64_TPREL16_LO;
13404                   rel->r_offset = offset + d_offset;
13405                   insn2 = 0x38630000;   /* addi 3,3,0 */
13406                 }
13407               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13408               /* Zap the reloc on the _tls_get_addr call too.  */
13409               BFD_ASSERT (offset == rel[1].r_offset);
13410               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13411               insn3 = bfd_get_32 (output_bfd,
13412                                   contents + offset + 4);
13413               if (insn3 == NOP
13414                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13415                 {
13416                   rel->r_offset += 4;
13417                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13418                   insn2 = NOP;
13419                 }
13420               bfd_put_32 (output_bfd, insn2, contents + offset);
13421               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13422                 {
13423                   rel--;
13424                   continue;
13425                 }
13426             }
13427           break;
13428
13429         case R_PPC64_TLSLD:
13430           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13431             {
13432               unsigned int insn2, insn3;
13433               bfd_vma offset = rel->r_offset;
13434
13435               if (toc_symndx)
13436                 sec = local_sections[toc_symndx];
13437               for (r_symndx = 0;
13438                    r_symndx < symtab_hdr->sh_info;
13439                    r_symndx++)
13440                 if (local_sections[r_symndx] == sec)
13441                   break;
13442               if (r_symndx >= symtab_hdr->sh_info)
13443                 r_symndx = STN_UNDEF;
13444               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13445               if (r_symndx != STN_UNDEF)
13446                 rel->r_addend -= (local_syms[r_symndx].st_value
13447                                   + sec->output_offset
13448                                   + sec->output_section->vma);
13449
13450               r_type = R_PPC64_TPREL16_LO;
13451               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13452               rel->r_offset = offset + d_offset;
13453               /* Zap the reloc on the _tls_get_addr call too.  */
13454               BFD_ASSERT (offset == rel[1].r_offset);
13455               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13456               insn2 = 0x38630000;       /* addi 3,3,0 */
13457               insn3 = bfd_get_32 (output_bfd,
13458                                   contents + offset + 4);
13459               if (insn3 == NOP
13460                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13461                 {
13462                   rel->r_offset += 4;
13463                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13464                   insn2 = NOP;
13465                 }
13466               bfd_put_32 (output_bfd, insn2, contents + offset);
13467               rel--;
13468               continue;
13469             }
13470           break;
13471
13472         case R_PPC64_DTPMOD64:
13473           if (rel + 1 < relend
13474               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13475               && rel[1].r_offset == rel->r_offset + 8)
13476             {
13477               if ((tls_mask & TLS_GD) == 0)
13478                 {
13479                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13480                   if ((tls_mask & TLS_TPRELGD) != 0)
13481                     r_type = R_PPC64_TPREL64;
13482                   else
13483                     {
13484                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13485                       r_type = R_PPC64_NONE;
13486                     }
13487                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13488                 }
13489             }
13490           else
13491             {
13492               if ((tls_mask & TLS_LD) == 0)
13493                 {
13494                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13495                   r_type = R_PPC64_NONE;
13496                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13497                 }
13498             }
13499           break;
13500
13501         case R_PPC64_TPREL64:
13502           if ((tls_mask & TLS_TPREL) == 0)
13503             {
13504               r_type = R_PPC64_NONE;
13505               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13506             }
13507           break;
13508
13509         case R_PPC64_REL16_HA:
13510           /* If we are generating a non-PIC executable, edit
13511              .  0:      addis 2,12,.TOC.-0b@ha
13512              .          addi 2,2,.TOC.-0b@l
13513              used by ELFv2 global entry points to set up r2, to
13514              .          lis 2,.TOC.@ha
13515              .          addi 2,2,.TOC.@l
13516              if .TOC. is in range.  */
13517           if (!info->shared
13518               && h != NULL && &h->elf == htab->elf.hgot
13519               && rel + 1 < relend
13520               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13521               && rel[1].r_offset == rel->r_offset + 4
13522               && rel[1].r_addend == rel->r_addend + 4
13523               && relocation + 0x80008000 <= 0xffffffff)
13524             {
13525               unsigned int insn1, insn2;
13526               bfd_vma offset = rel->r_offset - d_offset;
13527               insn1 = bfd_get_32 (output_bfd, contents + offset);
13528               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13529               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13530                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13531                 {
13532                   r_type = R_PPC64_ADDR16_HA;
13533                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13534                   rel->r_addend -= d_offset;
13535                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13536                   rel[1].r_addend -= d_offset + 4;
13537                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13538                 }
13539             }
13540           break;
13541         }
13542
13543       /* Handle other relocations that tweak non-addend part of insn.  */
13544       insn = 0;
13545       max_br_offset = 1 << 25;
13546       addend = rel->r_addend;
13547       reloc_dest = DEST_NORMAL;
13548       switch (r_type)
13549         {
13550         default:
13551           break;
13552
13553         case R_PPC64_TOCSAVE:
13554           if (relocation + addend == (rel->r_offset
13555                                       + input_section->output_offset
13556                                       + input_section->output_section->vma)
13557               && tocsave_find (htab, NO_INSERT,
13558                                &local_syms, rel, input_bfd))
13559             {
13560               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13561               if (insn == NOP
13562                   || insn == CROR_151515 || insn == CROR_313131)
13563                 bfd_put_32 (input_bfd,
13564                             STD_R2_0R1 + STK_TOC (htab),
13565                             contents + rel->r_offset);
13566             }
13567           break;
13568
13569           /* Branch taken prediction relocations.  */
13570         case R_PPC64_ADDR14_BRTAKEN:
13571         case R_PPC64_REL14_BRTAKEN:
13572           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13573           /* Fall thru.  */
13574
13575           /* Branch not taken prediction relocations.  */
13576         case R_PPC64_ADDR14_BRNTAKEN:
13577         case R_PPC64_REL14_BRNTAKEN:
13578           insn |= bfd_get_32 (output_bfd,
13579                               contents + rel->r_offset) & ~(0x01 << 21);
13580           /* Fall thru.  */
13581
13582         case R_PPC64_REL14:
13583           max_br_offset = 1 << 15;
13584           /* Fall thru.  */
13585
13586         case R_PPC64_REL24:
13587           /* Calls to functions with a different TOC, such as calls to
13588              shared objects, need to alter the TOC pointer.  This is
13589              done using a linkage stub.  A REL24 branching to these
13590              linkage stubs needs to be followed by a nop, as the nop
13591              will be replaced with an instruction to restore the TOC
13592              base pointer.  */
13593           fdh = h;
13594           if (h != NULL
13595               && h->oh != NULL
13596               && h->oh->is_func_descriptor)
13597             fdh = ppc_follow_link (h->oh);
13598           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13599                                            htab);
13600           if (stub_entry != NULL
13601               && (stub_entry->stub_type == ppc_stub_plt_call
13602                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13603                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13604                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13605             {
13606               bfd_boolean can_plt_call = FALSE;
13607
13608               /* All of these stubs will modify r2, so there must be a
13609                  branch and link followed by a nop.  The nop is
13610                  replaced by an insn to restore r2.  */
13611               if (rel->r_offset + 8 <= input_section->size)
13612                 {
13613                   unsigned long br;
13614
13615                   br = bfd_get_32 (input_bfd,
13616                                    contents + rel->r_offset);
13617                   if ((br & 1) != 0)
13618                     {
13619                       unsigned long nop;
13620
13621                       nop = bfd_get_32 (input_bfd,
13622                                         contents + rel->r_offset + 4);
13623                       if (nop == NOP
13624                           || nop == CROR_151515 || nop == CROR_313131)
13625                         {
13626                           if (h != NULL
13627                               && (h == htab->tls_get_addr_fd
13628                                   || h == htab->tls_get_addr)
13629                               && !htab->params->no_tls_get_addr_opt)
13630                             {
13631                               /* Special stub used, leave nop alone.  */
13632                             }
13633                           else
13634                             bfd_put_32 (input_bfd,
13635                                         LD_R2_0R1 + STK_TOC (htab),
13636                                         contents + rel->r_offset + 4);
13637                           can_plt_call = TRUE;
13638                         }
13639                     }
13640                 }
13641
13642               if (!can_plt_call && h != NULL)
13643                 {
13644                   const char *name = h->elf.root.root.string;
13645
13646                   if (*name == '.')
13647                     ++name;
13648
13649                   if (strncmp (name, "__libc_start_main", 17) == 0
13650                       && (name[17] == 0 || name[17] == '@'))
13651                     {
13652                       /* Allow crt1 branch to go via a toc adjusting
13653                          stub.  Other calls that never return could do
13654                          the same, if we could detect such.  */
13655                       can_plt_call = TRUE;
13656                     }
13657                 }
13658
13659               if (!can_plt_call)
13660                 {
13661                   /* g++ as of 20130507 emits self-calls without a
13662                      following nop.  This is arguably wrong since we
13663                      have conflicting information.  On the one hand a
13664                      global symbol and on the other a local call
13665                      sequence, but don't error for this special case.
13666                      It isn't possible to cheaply verify we have
13667                      exactly such a call.  Allow all calls to the same
13668                      section.  */
13669                   asection *code_sec = sec;
13670
13671                   if (get_opd_info (sec) != NULL)
13672                     {
13673                       bfd_vma off = (relocation + addend
13674                                      - sec->output_section->vma
13675                                      - sec->output_offset);
13676
13677                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13678                     }
13679                   if (code_sec == input_section)
13680                     can_plt_call = TRUE;
13681                 }
13682
13683               if (!can_plt_call)
13684                 {
13685                   info->callbacks->einfo
13686                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13687                        "recompile with -fPIC\n"),
13688                      input_bfd, input_section, rel->r_offset, sym_name);
13689
13690                   bfd_set_error (bfd_error_bad_value);
13691                   ret = FALSE;
13692                 }
13693
13694               if (can_plt_call
13695                   && (stub_entry->stub_type == ppc_stub_plt_call
13696                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13697                 unresolved_reloc = FALSE;
13698             }
13699
13700           if ((stub_entry == NULL
13701                || stub_entry->stub_type == ppc_stub_long_branch
13702                || stub_entry->stub_type == ppc_stub_plt_branch)
13703               && get_opd_info (sec) != NULL)
13704             {
13705               /* The branch destination is the value of the opd entry. */
13706               bfd_vma off = (relocation + addend
13707                              - sec->output_section->vma
13708                              - sec->output_offset);
13709               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13710               if (dest != (bfd_vma) -1)
13711                 {
13712                   relocation = dest;
13713                   addend = 0;
13714                   reloc_dest = DEST_OPD;
13715                 }
13716             }
13717
13718           /* If the branch is out of reach we ought to have a long
13719              branch stub.  */
13720           from = (rel->r_offset
13721                   + input_section->output_offset
13722                   + input_section->output_section->vma);
13723
13724           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13725                                                   ? fdh->elf.other
13726                                                   : sym->st_other);
13727
13728           if (stub_entry != NULL
13729               && (stub_entry->stub_type == ppc_stub_long_branch
13730                   || stub_entry->stub_type == ppc_stub_plt_branch)
13731               && (r_type == R_PPC64_ADDR14_BRTAKEN
13732                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13733                   || (relocation + addend - from + max_br_offset
13734                       < 2 * max_br_offset)))
13735             /* Don't use the stub if this branch is in range.  */
13736             stub_entry = NULL;
13737
13738           if (stub_entry != NULL)
13739             {
13740               /* Munge up the value and addend so that we call the stub
13741                  rather than the procedure directly.  */
13742               relocation = (stub_entry->stub_offset
13743                             + stub_entry->stub_sec->output_offset
13744                             + stub_entry->stub_sec->output_section->vma);
13745               addend = 0;
13746               reloc_dest = DEST_STUB;
13747
13748               if ((stub_entry->stub_type == ppc_stub_plt_call
13749                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13750                   && (ALWAYS_EMIT_R2SAVE
13751                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13752                   && rel + 1 < relend
13753                   && rel[1].r_offset == rel->r_offset + 4
13754                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13755                 relocation += 4;
13756             }
13757
13758           if (insn != 0)
13759             {
13760               if (is_isa_v2)
13761                 {
13762                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13763                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13764                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13765                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13766                     insn |= 0x02 << 21;
13767                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13768                     insn |= 0x08 << 21;
13769                   else
13770                     break;
13771                 }
13772               else
13773                 {
13774                   /* Invert 'y' bit if not the default.  */
13775                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13776                     insn ^= 0x01 << 21;
13777                 }
13778
13779               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13780             }
13781
13782           /* NOP out calls to undefined weak functions.
13783              We can thus call a weak function without first
13784              checking whether the function is defined.  */
13785           else if (h != NULL
13786                    && h->elf.root.type == bfd_link_hash_undefweak
13787                    && h->elf.dynindx == -1
13788                    && r_type == R_PPC64_REL24
13789                    && relocation == 0
13790                    && addend == 0)
13791             {
13792               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13793               continue;
13794             }
13795           break;
13796         }
13797
13798       /* Set `addend'.  */
13799       tls_type = 0;
13800       switch (r_type)
13801         {
13802         default:
13803           info->callbacks->einfo
13804             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13805              input_bfd, (int) r_type, sym_name);
13806
13807           bfd_set_error (bfd_error_bad_value);
13808           ret = FALSE;
13809           continue;
13810
13811         case R_PPC64_NONE:
13812         case R_PPC64_TLS:
13813         case R_PPC64_TLSGD:
13814         case R_PPC64_TLSLD:
13815         case R_PPC64_TOCSAVE:
13816         case R_PPC64_GNU_VTINHERIT:
13817         case R_PPC64_GNU_VTENTRY:
13818           continue;
13819
13820           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13821              address in the GOT as relocation value instead of the
13822              symbol's value itself.  Also, create a GOT entry for the
13823              symbol and put the symbol value there.  */
13824         case R_PPC64_GOT_TLSGD16:
13825         case R_PPC64_GOT_TLSGD16_LO:
13826         case R_PPC64_GOT_TLSGD16_HI:
13827         case R_PPC64_GOT_TLSGD16_HA:
13828           tls_type = TLS_TLS | TLS_GD;
13829           goto dogot;
13830
13831         case R_PPC64_GOT_TLSLD16:
13832         case R_PPC64_GOT_TLSLD16_LO:
13833         case R_PPC64_GOT_TLSLD16_HI:
13834         case R_PPC64_GOT_TLSLD16_HA:
13835           tls_type = TLS_TLS | TLS_LD;
13836           goto dogot;
13837
13838         case R_PPC64_GOT_TPREL16_DS:
13839         case R_PPC64_GOT_TPREL16_LO_DS:
13840         case R_PPC64_GOT_TPREL16_HI:
13841         case R_PPC64_GOT_TPREL16_HA:
13842           tls_type = TLS_TLS | TLS_TPREL;
13843           goto dogot;
13844
13845         case R_PPC64_GOT_DTPREL16_DS:
13846         case R_PPC64_GOT_DTPREL16_LO_DS:
13847         case R_PPC64_GOT_DTPREL16_HI:
13848         case R_PPC64_GOT_DTPREL16_HA:
13849           tls_type = TLS_TLS | TLS_DTPREL;
13850           goto dogot;
13851
13852         case R_PPC64_GOT16:
13853         case R_PPC64_GOT16_LO:
13854         case R_PPC64_GOT16_HI:
13855         case R_PPC64_GOT16_HA:
13856         case R_PPC64_GOT16_DS:
13857         case R_PPC64_GOT16_LO_DS:
13858         dogot:
13859           {
13860             /* Relocation is to the entry for this symbol in the global
13861                offset table.  */
13862             asection *got;
13863             bfd_vma *offp;
13864             bfd_vma off;
13865             unsigned long indx = 0;
13866             struct got_entry *ent;
13867
13868             if (tls_type == (TLS_TLS | TLS_LD)
13869                 && (h == NULL
13870                     || !h->elf.def_dynamic))
13871               ent = ppc64_tlsld_got (input_bfd);
13872             else
13873               {
13874
13875                 if (h != NULL)
13876                   {
13877                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13878                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13879                                                           &h->elf)
13880                         || (info->shared
13881                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13882                       /* This is actually a static link, or it is a
13883                          -Bsymbolic link and the symbol is defined
13884                          locally, or the symbol was forced to be local
13885                          because of a version file.  */
13886                       ;
13887                     else
13888                       {
13889                         BFD_ASSERT (h->elf.dynindx != -1);
13890                         indx = h->elf.dynindx;
13891                         unresolved_reloc = FALSE;
13892                       }
13893                     ent = h->elf.got.glist;
13894                   }
13895                 else
13896                   {
13897                     if (local_got_ents == NULL)
13898                       abort ();
13899                     ent = local_got_ents[r_symndx];
13900                   }
13901
13902                 for (; ent != NULL; ent = ent->next)
13903                   if (ent->addend == orig_rel.r_addend
13904                       && ent->owner == input_bfd
13905                       && ent->tls_type == tls_type)
13906                     break;
13907               }
13908
13909             if (ent == NULL)
13910               abort ();
13911             if (ent->is_indirect)
13912               ent = ent->got.ent;
13913             offp = &ent->got.offset;
13914             got = ppc64_elf_tdata (ent->owner)->got;
13915             if (got == NULL)
13916               abort ();
13917
13918             /* The offset must always be a multiple of 8.  We use the
13919                least significant bit to record whether we have already
13920                processed this entry.  */
13921             off = *offp;
13922             if ((off & 1) != 0)
13923               off &= ~1;
13924             else
13925               {
13926                 /* Generate relocs for the dynamic linker, except in
13927                    the case of TLSLD where we'll use one entry per
13928                    module.  */
13929                 asection *relgot;
13930                 bfd_boolean ifunc;
13931
13932                 *offp = off | 1;
13933                 relgot = NULL;
13934                 ifunc = (h != NULL
13935                          ? h->elf.type == STT_GNU_IFUNC
13936                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13937                 if (ifunc)
13938                   relgot = htab->elf.irelplt;
13939                 else if ((info->shared || indx != 0)
13940                          && (h == NULL
13941                              || (tls_type == (TLS_TLS | TLS_LD)
13942                                  && !h->elf.def_dynamic)
13943                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13944                              || h->elf.root.type != bfd_link_hash_undefweak))
13945                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13946                 if (relgot != NULL)
13947                   {
13948                     outrel.r_offset = (got->output_section->vma
13949                                        + got->output_offset
13950                                        + off);
13951                     outrel.r_addend = addend;
13952                     if (tls_type & (TLS_LD | TLS_GD))
13953                       {
13954                         outrel.r_addend = 0;
13955                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13956                         if (tls_type == (TLS_TLS | TLS_GD))
13957                           {
13958                             loc = relgot->contents;
13959                             loc += (relgot->reloc_count++
13960                                     * sizeof (Elf64_External_Rela));
13961                             bfd_elf64_swap_reloca_out (output_bfd,
13962                                                        &outrel, loc);
13963                             outrel.r_offset += 8;
13964                             outrel.r_addend = addend;
13965                             outrel.r_info
13966                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13967                           }
13968                       }
13969                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13970                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13971                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13972                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13973                     else if (indx != 0)
13974                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13975                     else
13976                       {
13977                         if (ifunc)
13978                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13979                         else
13980                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13981
13982                         /* Write the .got section contents for the sake
13983                            of prelink.  */
13984                         loc = got->contents + off;
13985                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13986                                     loc);
13987                       }
13988
13989                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13990                       {
13991                         outrel.r_addend += relocation;
13992                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13993                           outrel.r_addend -= htab->elf.tls_sec->vma;
13994                       }
13995                     loc = relgot->contents;
13996                     loc += (relgot->reloc_count++
13997                             * sizeof (Elf64_External_Rela));
13998                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13999                   }
14000
14001                 /* Init the .got section contents here if we're not
14002                    emitting a reloc.  */
14003                 else
14004                   {
14005                     relocation += addend;
14006                     if (tls_type == (TLS_TLS | TLS_LD))
14007                       relocation = 1;
14008                     else if (tls_type != 0)
14009                       {
14010                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14011                         if (tls_type == (TLS_TLS | TLS_TPREL))
14012                           relocation += DTP_OFFSET - TP_OFFSET;
14013
14014                         if (tls_type == (TLS_TLS | TLS_GD))
14015                           {
14016                             bfd_put_64 (output_bfd, relocation,
14017                                         got->contents + off + 8);
14018                             relocation = 1;
14019                           }
14020                       }
14021
14022                     bfd_put_64 (output_bfd, relocation,
14023                                 got->contents + off);
14024                   }
14025               }
14026
14027             if (off >= (bfd_vma) -2)
14028               abort ();
14029
14030             relocation = got->output_section->vma + got->output_offset + off;
14031             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14032           }
14033           break;
14034
14035         case R_PPC64_PLT16_HA:
14036         case R_PPC64_PLT16_HI:
14037         case R_PPC64_PLT16_LO:
14038         case R_PPC64_PLT32:
14039         case R_PPC64_PLT64:
14040           /* Relocation is to the entry for this symbol in the
14041              procedure linkage table.  */
14042
14043           /* Resolve a PLT reloc against a local symbol directly,
14044              without using the procedure linkage table.  */
14045           if (h == NULL)
14046             break;
14047
14048           /* It's possible that we didn't make a PLT entry for this
14049              symbol.  This happens when statically linking PIC code,
14050              or when using -Bsymbolic.  Go find a match if there is a
14051              PLT entry.  */
14052           if (htab->elf.splt != NULL)
14053             {
14054               struct plt_entry *ent;
14055               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14056                 if (ent->plt.offset != (bfd_vma) -1
14057                     && ent->addend == orig_rel.r_addend)
14058                   {
14059                     relocation = (htab->elf.splt->output_section->vma
14060                                   + htab->elf.splt->output_offset
14061                                   + ent->plt.offset);
14062                     unresolved_reloc = FALSE;
14063                     break;
14064                   }
14065             }
14066           break;
14067
14068         case R_PPC64_TOC:
14069           /* Relocation value is TOC base.  */
14070           relocation = TOCstart;
14071           if (r_symndx == STN_UNDEF)
14072             relocation += htab->stub_group[input_section->id].toc_off;
14073           else if (unresolved_reloc)
14074             ;
14075           else if (sec != NULL && sec->id <= htab->top_id)
14076             relocation += htab->stub_group[sec->id].toc_off;
14077           else
14078             unresolved_reloc = TRUE;
14079           goto dodyn;
14080
14081           /* TOC16 relocs.  We want the offset relative to the TOC base,
14082              which is the address of the start of the TOC plus 0x8000.
14083              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14084              in this order.  */
14085         case R_PPC64_TOC16:
14086         case R_PPC64_TOC16_LO:
14087         case R_PPC64_TOC16_HI:
14088         case R_PPC64_TOC16_DS:
14089         case R_PPC64_TOC16_LO_DS:
14090         case R_PPC64_TOC16_HA:
14091           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14092           break;
14093
14094           /* Relocate against the beginning of the section.  */
14095         case R_PPC64_SECTOFF:
14096         case R_PPC64_SECTOFF_LO:
14097         case R_PPC64_SECTOFF_HI:
14098         case R_PPC64_SECTOFF_DS:
14099         case R_PPC64_SECTOFF_LO_DS:
14100         case R_PPC64_SECTOFF_HA:
14101           if (sec != NULL)
14102             addend -= sec->output_section->vma;
14103           break;
14104
14105         case R_PPC64_REL16:
14106         case R_PPC64_REL16_LO:
14107         case R_PPC64_REL16_HI:
14108         case R_PPC64_REL16_HA:
14109           break;
14110
14111         case R_PPC64_REL14:
14112         case R_PPC64_REL14_BRNTAKEN:
14113         case R_PPC64_REL14_BRTAKEN:
14114         case R_PPC64_REL24:
14115           break;
14116
14117         case R_PPC64_TPREL16:
14118         case R_PPC64_TPREL16_LO:
14119         case R_PPC64_TPREL16_HI:
14120         case R_PPC64_TPREL16_HA:
14121         case R_PPC64_TPREL16_DS:
14122         case R_PPC64_TPREL16_LO_DS:
14123         case R_PPC64_TPREL16_HIGH:
14124         case R_PPC64_TPREL16_HIGHA:
14125         case R_PPC64_TPREL16_HIGHER:
14126         case R_PPC64_TPREL16_HIGHERA:
14127         case R_PPC64_TPREL16_HIGHEST:
14128         case R_PPC64_TPREL16_HIGHESTA:
14129           if (h != NULL
14130               && h->elf.root.type == bfd_link_hash_undefweak
14131               && h->elf.dynindx == -1)
14132             {
14133               /* Make this relocation against an undefined weak symbol
14134                  resolve to zero.  This is really just a tweak, since
14135                  code using weak externs ought to check that they are
14136                  defined before using them.  */
14137               bfd_byte *p = contents + rel->r_offset - d_offset;
14138
14139               insn = bfd_get_32 (output_bfd, p);
14140               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14141               if (insn != 0)
14142                 bfd_put_32 (output_bfd, insn, p);
14143               break;
14144             }
14145           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146           if (info->shared)
14147             /* The TPREL16 relocs shouldn't really be used in shared
14148                libs as they will result in DT_TEXTREL being set, but
14149                support them anyway.  */
14150             goto dodyn;
14151           break;
14152
14153         case R_PPC64_DTPREL16:
14154         case R_PPC64_DTPREL16_LO:
14155         case R_PPC64_DTPREL16_HI:
14156         case R_PPC64_DTPREL16_HA:
14157         case R_PPC64_DTPREL16_DS:
14158         case R_PPC64_DTPREL16_LO_DS:
14159         case R_PPC64_DTPREL16_HIGH:
14160         case R_PPC64_DTPREL16_HIGHA:
14161         case R_PPC64_DTPREL16_HIGHER:
14162         case R_PPC64_DTPREL16_HIGHERA:
14163         case R_PPC64_DTPREL16_HIGHEST:
14164         case R_PPC64_DTPREL16_HIGHESTA:
14165           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14166           break;
14167
14168         case R_PPC64_ADDR64_LOCAL:
14169           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14170                                               ? h->elf.other
14171                                               : sym->st_other);
14172           break;
14173
14174         case R_PPC64_DTPMOD64:
14175           relocation = 1;
14176           addend = 0;
14177           goto dodyn;
14178
14179         case R_PPC64_TPREL64:
14180           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14181           goto dodyn;
14182
14183         case R_PPC64_DTPREL64:
14184           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14185           /* Fall thru */
14186
14187           /* Relocations that may need to be propagated if this is a
14188              dynamic object.  */
14189         case R_PPC64_REL30:
14190         case R_PPC64_REL32:
14191         case R_PPC64_REL64:
14192         case R_PPC64_ADDR14:
14193         case R_PPC64_ADDR14_BRNTAKEN:
14194         case R_PPC64_ADDR14_BRTAKEN:
14195         case R_PPC64_ADDR16:
14196         case R_PPC64_ADDR16_DS:
14197         case R_PPC64_ADDR16_HA:
14198         case R_PPC64_ADDR16_HI:
14199         case R_PPC64_ADDR16_HIGH:
14200         case R_PPC64_ADDR16_HIGHA:
14201         case R_PPC64_ADDR16_HIGHER:
14202         case R_PPC64_ADDR16_HIGHERA:
14203         case R_PPC64_ADDR16_HIGHEST:
14204         case R_PPC64_ADDR16_HIGHESTA:
14205         case R_PPC64_ADDR16_LO:
14206         case R_PPC64_ADDR16_LO_DS:
14207         case R_PPC64_ADDR24:
14208         case R_PPC64_ADDR32:
14209         case R_PPC64_ADDR64:
14210         case R_PPC64_UADDR16:
14211         case R_PPC64_UADDR32:
14212         case R_PPC64_UADDR64:
14213         dodyn:
14214           if ((input_section->flags & SEC_ALLOC) == 0)
14215             break;
14216
14217           if (NO_OPD_RELOCS && is_opd)
14218             break;
14219
14220           if ((info->shared
14221                && (h == NULL
14222                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14223                    || h->elf.root.type != bfd_link_hash_undefweak)
14224                && (must_be_dyn_reloc (info, r_type)
14225                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14226               || (ELIMINATE_COPY_RELOCS
14227                   && !info->shared
14228                   && h != NULL
14229                   && h->elf.dynindx != -1
14230                   && !h->elf.non_got_ref
14231                   && !h->elf.def_regular)
14232               || (!info->shared
14233                   && (h != NULL
14234                       ? h->elf.type == STT_GNU_IFUNC
14235                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14236             {
14237               bfd_boolean skip, relocate;
14238               asection *sreloc;
14239               bfd_vma out_off;
14240
14241               /* When generating a dynamic object, these relocations
14242                  are copied into the output file to be resolved at run
14243                  time.  */
14244
14245               skip = FALSE;
14246               relocate = FALSE;
14247
14248               out_off = _bfd_elf_section_offset (output_bfd, info,
14249                                                  input_section, rel->r_offset);
14250               if (out_off == (bfd_vma) -1)
14251                 skip = TRUE;
14252               else if (out_off == (bfd_vma) -2)
14253                 skip = TRUE, relocate = TRUE;
14254               out_off += (input_section->output_section->vma
14255                           + input_section->output_offset);
14256               outrel.r_offset = out_off;
14257               outrel.r_addend = rel->r_addend;
14258
14259               /* Optimize unaligned reloc use.  */
14260               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14261                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14262                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14263               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14264                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14265                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14266               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14267                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14268                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14269
14270               if (skip)
14271                 memset (&outrel, 0, sizeof outrel);
14272               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14273                        && !is_opd
14274                        && r_type != R_PPC64_TOC)
14275                 {
14276                   BFD_ASSERT (h->elf.dynindx != -1);
14277                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14278                 }
14279               else
14280                 {
14281                   /* This symbol is local, or marked to become local,
14282                      or this is an opd section reloc which must point
14283                      at a local function.  */
14284                   outrel.r_addend += relocation;
14285                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14286                     {
14287                       if (is_opd && h != NULL)
14288                         {
14289                           /* Lie about opd entries.  This case occurs
14290                              when building shared libraries and we
14291                              reference a function in another shared
14292                              lib.  The same thing happens for a weak
14293                              definition in an application that's
14294                              overridden by a strong definition in a
14295                              shared lib.  (I believe this is a generic
14296                              bug in binutils handling of weak syms.)
14297                              In these cases we won't use the opd
14298                              entry in this lib.  */
14299                           unresolved_reloc = FALSE;
14300                         }
14301                       if (!is_opd
14302                           && r_type == R_PPC64_ADDR64
14303                           && (h != NULL
14304                               ? h->elf.type == STT_GNU_IFUNC
14305                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14306                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14307                       else
14308                         {
14309                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14310
14311                           /* We need to relocate .opd contents for ld.so.
14312                              Prelink also wants simple and consistent rules
14313                              for relocs.  This make all RELATIVE relocs have
14314                              *r_offset equal to r_addend.  */
14315                           relocate = TRUE;
14316                         }
14317                     }
14318                   else
14319                     {
14320                       long indx = 0;
14321
14322                       if (h != NULL
14323                           ? h->elf.type == STT_GNU_IFUNC
14324                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14325                         {
14326                           info->callbacks->einfo
14327                             (_("%P: %H: %s for indirect "
14328                                "function `%T' unsupported\n"),
14329                              input_bfd, input_section, rel->r_offset,
14330                              ppc64_elf_howto_table[r_type]->name,
14331                              sym_name);
14332                           ret = FALSE;
14333                         }
14334                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14335                         ;
14336                       else if (sec == NULL || sec->owner == NULL)
14337                         {
14338                           bfd_set_error (bfd_error_bad_value);
14339                           return FALSE;
14340                         }
14341                       else
14342                         {
14343                           asection *osec;
14344
14345                           osec = sec->output_section;
14346                           indx = elf_section_data (osec)->dynindx;
14347
14348                           if (indx == 0)
14349                             {
14350                               if ((osec->flags & SEC_READONLY) == 0
14351                                   && htab->elf.data_index_section != NULL)
14352                                 osec = htab->elf.data_index_section;
14353                               else
14354                                 osec = htab->elf.text_index_section;
14355                               indx = elf_section_data (osec)->dynindx;
14356                             }
14357                           BFD_ASSERT (indx != 0);
14358
14359                           /* We are turning this relocation into one
14360                              against a section symbol, so subtract out
14361                              the output section's address but not the
14362                              offset of the input section in the output
14363                              section.  */
14364                           outrel.r_addend -= osec->vma;
14365                         }
14366
14367                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14368                     }
14369                 }
14370
14371               sreloc = elf_section_data (input_section)->sreloc;
14372               if (h != NULL
14373                   ? h->elf.type == STT_GNU_IFUNC
14374                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14375                 sreloc = htab->elf.irelplt;
14376               if (sreloc == NULL)
14377                 abort ();
14378
14379               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14380                   >= sreloc->size)
14381                 abort ();
14382               loc = sreloc->contents;
14383               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14384               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14385
14386               /* If this reloc is against an external symbol, it will
14387                  be computed at runtime, so there's no need to do
14388                  anything now.  However, for the sake of prelink ensure
14389                  that the section contents are a known value.  */
14390               if (! relocate)
14391                 {
14392                   unresolved_reloc = FALSE;
14393                   /* The value chosen here is quite arbitrary as ld.so
14394                      ignores section contents except for the special
14395                      case of .opd where the contents might be accessed
14396                      before relocation.  Choose zero, as that won't
14397                      cause reloc overflow.  */
14398                   relocation = 0;
14399                   addend = 0;
14400                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14401                      to improve backward compatibility with older
14402                      versions of ld.  */
14403                   if (r_type == R_PPC64_ADDR64)
14404                     addend = outrel.r_addend;
14405                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14406                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14407                     addend = (input_section->output_section->vma
14408                               + input_section->output_offset
14409                               + rel->r_offset);
14410                 }
14411             }
14412           break;
14413
14414         case R_PPC64_COPY:
14415         case R_PPC64_GLOB_DAT:
14416         case R_PPC64_JMP_SLOT:
14417         case R_PPC64_JMP_IREL:
14418         case R_PPC64_RELATIVE:
14419           /* We shouldn't ever see these dynamic relocs in relocatable
14420              files.  */
14421           /* Fall through.  */
14422
14423         case R_PPC64_PLTGOT16:
14424         case R_PPC64_PLTGOT16_DS:
14425         case R_PPC64_PLTGOT16_HA:
14426         case R_PPC64_PLTGOT16_HI:
14427         case R_PPC64_PLTGOT16_LO:
14428         case R_PPC64_PLTGOT16_LO_DS:
14429         case R_PPC64_PLTREL32:
14430         case R_PPC64_PLTREL64:
14431           /* These ones haven't been implemented yet.  */
14432
14433           info->callbacks->einfo
14434             (_("%P: %B: %s is not supported for `%T'\n"),
14435              input_bfd,
14436              ppc64_elf_howto_table[r_type]->name, sym_name);
14437
14438           bfd_set_error (bfd_error_invalid_operation);
14439           ret = FALSE;
14440           continue;
14441         }
14442
14443       /* Multi-instruction sequences that access the TOC can be
14444          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14445          to             nop;           addi rb,r2,x;  */
14446       switch (r_type)
14447         {
14448         default:
14449           break;
14450
14451         case R_PPC64_GOT_TLSLD16_HI:
14452         case R_PPC64_GOT_TLSGD16_HI:
14453         case R_PPC64_GOT_TPREL16_HI:
14454         case R_PPC64_GOT_DTPREL16_HI:
14455         case R_PPC64_GOT16_HI:
14456         case R_PPC64_TOC16_HI:
14457           /* These relocs would only be useful if building up an
14458              offset to later add to r2, perhaps in an indexed
14459              addressing mode instruction.  Don't try to optimize.
14460              Unfortunately, the possibility of someone building up an
14461              offset like this or even with the HA relocs, means that
14462              we need to check the high insn when optimizing the low
14463              insn.  */
14464           break;
14465
14466         case R_PPC64_GOT_TLSLD16_HA:
14467         case R_PPC64_GOT_TLSGD16_HA:
14468         case R_PPC64_GOT_TPREL16_HA:
14469         case R_PPC64_GOT_DTPREL16_HA:
14470         case R_PPC64_GOT16_HA:
14471         case R_PPC64_TOC16_HA:
14472           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14473               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14474             {
14475               bfd_byte *p = contents + (rel->r_offset & ~3);
14476               bfd_put_32 (input_bfd, NOP, p);
14477             }
14478           break;
14479
14480         case R_PPC64_GOT_TLSLD16_LO:
14481         case R_PPC64_GOT_TLSGD16_LO:
14482         case R_PPC64_GOT_TPREL16_LO_DS:
14483         case R_PPC64_GOT_DTPREL16_LO_DS:
14484         case R_PPC64_GOT16_LO:
14485         case R_PPC64_GOT16_LO_DS:
14486         case R_PPC64_TOC16_LO:
14487         case R_PPC64_TOC16_LO_DS:
14488           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14489               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14490             {
14491               bfd_byte *p = contents + (rel->r_offset & ~3);
14492               insn = bfd_get_32 (input_bfd, p);
14493               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14494                 {
14495                   /* Transform addic to addi when we change reg.  */
14496                   insn &= ~((0x3f << 26) | (0x1f << 16));
14497                   insn |= (14u << 26) | (2 << 16);
14498                 }
14499               else
14500                 {
14501                   insn &= ~(0x1f << 16);
14502                   insn |= 2 << 16;
14503                 }
14504               bfd_put_32 (input_bfd, insn, p);
14505             }
14506           break;
14507         }
14508
14509       /* Do any further special processing.  */
14510       switch (r_type)
14511         {
14512         default:
14513           break;
14514
14515         case R_PPC64_REL16_HA:
14516         case R_PPC64_ADDR16_HA:
14517         case R_PPC64_ADDR16_HIGHA:
14518         case R_PPC64_ADDR16_HIGHERA:
14519         case R_PPC64_ADDR16_HIGHESTA:
14520         case R_PPC64_TOC16_HA:
14521         case R_PPC64_SECTOFF_HA:
14522         case R_PPC64_TPREL16_HA:
14523         case R_PPC64_TPREL16_HIGHA:
14524         case R_PPC64_TPREL16_HIGHERA:
14525         case R_PPC64_TPREL16_HIGHESTA:
14526         case R_PPC64_DTPREL16_HA:
14527         case R_PPC64_DTPREL16_HIGHA:
14528         case R_PPC64_DTPREL16_HIGHERA:
14529         case R_PPC64_DTPREL16_HIGHESTA:
14530           /* It's just possible that this symbol is a weak symbol
14531              that's not actually defined anywhere. In that case,
14532              'sec' would be NULL, and we should leave the symbol
14533              alone (it will be set to zero elsewhere in the link).  */
14534           if (sec == NULL)
14535             break;
14536           /* Fall thru */
14537
14538         case R_PPC64_GOT16_HA:
14539         case R_PPC64_PLTGOT16_HA:
14540         case R_PPC64_PLT16_HA:
14541         case R_PPC64_GOT_TLSGD16_HA:
14542         case R_PPC64_GOT_TLSLD16_HA:
14543         case R_PPC64_GOT_TPREL16_HA:
14544         case R_PPC64_GOT_DTPREL16_HA:
14545           /* Add 0x10000 if sign bit in 0:15 is set.
14546              Bits 0:15 are not used.  */
14547           addend += 0x8000;
14548           break;
14549
14550         case R_PPC64_ADDR16_DS:
14551         case R_PPC64_ADDR16_LO_DS:
14552         case R_PPC64_GOT16_DS:
14553         case R_PPC64_GOT16_LO_DS:
14554         case R_PPC64_PLT16_LO_DS:
14555         case R_PPC64_SECTOFF_DS:
14556         case R_PPC64_SECTOFF_LO_DS:
14557         case R_PPC64_TOC16_DS:
14558         case R_PPC64_TOC16_LO_DS:
14559         case R_PPC64_PLTGOT16_DS:
14560         case R_PPC64_PLTGOT16_LO_DS:
14561         case R_PPC64_GOT_TPREL16_DS:
14562         case R_PPC64_GOT_TPREL16_LO_DS:
14563         case R_PPC64_GOT_DTPREL16_DS:
14564         case R_PPC64_GOT_DTPREL16_LO_DS:
14565         case R_PPC64_TPREL16_DS:
14566         case R_PPC64_TPREL16_LO_DS:
14567         case R_PPC64_DTPREL16_DS:
14568         case R_PPC64_DTPREL16_LO_DS:
14569           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14570           mask = 3;
14571           /* If this reloc is against an lq insn, then the value must be
14572              a multiple of 16.  This is somewhat of a hack, but the
14573              "correct" way to do this by defining _DQ forms of all the
14574              _DS relocs bloats all reloc switches in this file.  It
14575              doesn't seem to make much sense to use any of these relocs
14576              in data, so testing the insn should be safe.  */
14577           if ((insn & (0x3f << 26)) == (56u << 26))
14578             mask = 15;
14579           if (((relocation + addend) & mask) != 0)
14580             {
14581               info->callbacks->einfo
14582                 (_("%P: %H: error: %s not a multiple of %u\n"),
14583                  input_bfd, input_section, rel->r_offset,
14584                  ppc64_elf_howto_table[r_type]->name,
14585                  mask + 1);
14586               bfd_set_error (bfd_error_bad_value);
14587               ret = FALSE;
14588               continue;
14589             }
14590           break;
14591         }
14592
14593       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14594          because such sections are not SEC_ALLOC and thus ld.so will
14595          not process them.  */
14596       if (unresolved_reloc
14597           && !((input_section->flags & SEC_DEBUGGING) != 0
14598                && h->elf.def_dynamic)
14599           && _bfd_elf_section_offset (output_bfd, info, input_section,
14600                                       rel->r_offset) != (bfd_vma) -1)
14601         {
14602           info->callbacks->einfo
14603             (_("%P: %H: unresolvable %s against `%T'\n"),
14604              input_bfd, input_section, rel->r_offset,
14605              ppc64_elf_howto_table[(int) r_type]->name,
14606              h->elf.root.root.string);
14607           ret = FALSE;
14608         }
14609
14610       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14611                                     input_bfd,
14612                                     input_section,
14613                                     contents,
14614                                     rel->r_offset,
14615                                     relocation,
14616                                     addend);
14617
14618       if (r != bfd_reloc_ok)
14619         {
14620           char *more_info = NULL;
14621           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14622
14623           if (reloc_dest != DEST_NORMAL)
14624             {
14625               more_info = bfd_malloc (strlen (reloc_name) + 8);
14626               if (more_info != NULL)
14627                 {
14628                   strcpy (more_info, reloc_name);
14629                   strcat (more_info, (reloc_dest == DEST_OPD
14630                                       ? " (OPD)" : " (stub)"));
14631                   reloc_name = more_info;
14632                 }
14633             }
14634
14635           if (r == bfd_reloc_overflow)
14636             {
14637               if (warned)
14638                 continue;
14639               if (h != NULL
14640                   && h->elf.root.type == bfd_link_hash_undefweak
14641                   && ppc64_elf_howto_table[r_type]->pc_relative)
14642                 {
14643                   /* Assume this is a call protected by other code that
14644                      detects the symbol is undefined.  If this is the case,
14645                      we can safely ignore the overflow.  If not, the
14646                      program is hosed anyway, and a little warning isn't
14647                      going to help.  */
14648
14649                   continue;
14650                 }
14651
14652               if (!((*info->callbacks->reloc_overflow)
14653                     (info, &h->elf.root, sym_name,
14654                      reloc_name, orig_rel.r_addend,
14655                      input_bfd, input_section, rel->r_offset)))
14656                 return FALSE;
14657             }
14658           else
14659             {
14660               info->callbacks->einfo
14661                 (_("%P: %H: %s against `%T': error %d\n"),
14662                  input_bfd, input_section, rel->r_offset,
14663                  reloc_name, sym_name, (int) r);
14664               ret = FALSE;
14665             }
14666           if (more_info != NULL)
14667             free (more_info);
14668         }
14669     }
14670
14671   /* If we're emitting relocations, then shortly after this function
14672      returns, reloc offsets and addends for this section will be
14673      adjusted.  Worse, reloc symbol indices will be for the output
14674      file rather than the input.  Save a copy of the relocs for
14675      opd_entry_value.  */
14676   if (is_opd && (info->emitrelocations || info->relocatable))
14677     {
14678       bfd_size_type amt;
14679       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14680       rel = bfd_alloc (input_bfd, amt);
14681       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14682       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14683       if (rel == NULL)
14684         return FALSE;
14685       memcpy (rel, relocs, amt);
14686     }
14687   return ret;
14688 }
14689
14690 /* Adjust the value of any local symbols in opd sections.  */
14691
14692 static int
14693 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14694                               const char *name ATTRIBUTE_UNUSED,
14695                               Elf_Internal_Sym *elfsym,
14696                               asection *input_sec,
14697                               struct elf_link_hash_entry *h)
14698 {
14699   struct _opd_sec_data *opd;
14700   long adjust;
14701   bfd_vma value;
14702
14703   if (h != NULL)
14704     return 1;
14705
14706   opd = get_opd_info (input_sec);
14707   if (opd == NULL || opd->adjust == NULL)
14708     return 1;
14709
14710   value = elfsym->st_value - input_sec->output_offset;
14711   if (!info->relocatable)
14712     value -= input_sec->output_section->vma;
14713
14714   adjust = opd->adjust[value / 8];
14715   if (adjust == -1)
14716     return 2;
14717
14718   elfsym->st_value += adjust;
14719   return 1;
14720 }
14721
14722 /* Finish up dynamic symbol handling.  We set the contents of various
14723    dynamic sections here.  */
14724
14725 static bfd_boolean
14726 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14727                                  struct bfd_link_info *info,
14728                                  struct elf_link_hash_entry *h,
14729                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14730 {
14731   struct ppc_link_hash_table *htab;
14732   struct plt_entry *ent;
14733   Elf_Internal_Rela rela;
14734   bfd_byte *loc;
14735
14736   htab = ppc_hash_table (info);
14737   if (htab == NULL)
14738     return FALSE;
14739
14740   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14741     if (ent->plt.offset != (bfd_vma) -1)
14742       {
14743         /* This symbol has an entry in the procedure linkage
14744            table.  Set it up.  */
14745         if (!htab->elf.dynamic_sections_created
14746             || h->dynindx == -1)
14747           {
14748             BFD_ASSERT (h->type == STT_GNU_IFUNC
14749                         && h->def_regular
14750                         && (h->root.type == bfd_link_hash_defined
14751                             || h->root.type == bfd_link_hash_defweak));
14752             rela.r_offset = (htab->elf.iplt->output_section->vma
14753                              + htab->elf.iplt->output_offset
14754                              + ent->plt.offset);
14755             if (htab->opd_abi)
14756               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14757             else
14758               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14759             rela.r_addend = (h->root.u.def.value
14760                              + h->root.u.def.section->output_offset
14761                              + h->root.u.def.section->output_section->vma
14762                              + ent->addend);
14763             loc = (htab->elf.irelplt->contents
14764                    + (htab->elf.irelplt->reloc_count++
14765                       * sizeof (Elf64_External_Rela)));
14766           }
14767         else
14768           {
14769             rela.r_offset = (htab->elf.splt->output_section->vma
14770                              + htab->elf.splt->output_offset
14771                              + ent->plt.offset);
14772             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14773             rela.r_addend = ent->addend;
14774             loc = (htab->elf.srelplt->contents
14775                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14776                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14777           }
14778         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14779
14780         if (!htab->opd_abi)
14781           {
14782             if (!h->def_regular)
14783               {
14784                 /* Mark the symbol as undefined, rather than as
14785                    defined in glink.  Leave the value if there were
14786                    any relocations where pointer equality matters
14787                    (this is a clue for the dynamic linker, to make
14788                    function pointer comparisons work between an
14789                    application and shared library), otherwise set it
14790                    to zero.  */
14791                 sym->st_shndx = SHN_UNDEF;
14792                 if (!h->pointer_equality_needed)
14793                   sym->st_value = 0;
14794                 else if (!h->ref_regular_nonweak)
14795                   {
14796                     /* This breaks function pointer comparisons, but
14797                        that is better than breaking tests for a NULL
14798                        function pointer.  */
14799                     sym->st_value = 0;
14800                   }
14801               }
14802           }
14803       }
14804
14805   if (h->needs_copy)
14806     {
14807       /* This symbol needs a copy reloc.  Set it up.  */
14808
14809       if (h->dynindx == -1
14810           || (h->root.type != bfd_link_hash_defined
14811               && h->root.type != bfd_link_hash_defweak)
14812           || htab->relbss == NULL)
14813         abort ();
14814
14815       rela.r_offset = (h->root.u.def.value
14816                        + h->root.u.def.section->output_section->vma
14817                        + h->root.u.def.section->output_offset);
14818       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14819       rela.r_addend = 0;
14820       loc = htab->relbss->contents;
14821       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14822       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14823     }
14824
14825   return TRUE;
14826 }
14827
14828 /* Used to decide how to sort relocs in an optimal manner for the
14829    dynamic linker, before writing them out.  */
14830
14831 static enum elf_reloc_type_class
14832 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14833                             const asection *rel_sec,
14834                             const Elf_Internal_Rela *rela)
14835 {
14836   enum elf_ppc64_reloc_type r_type;
14837   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14838
14839   if (rel_sec == htab->elf.irelplt)
14840     return reloc_class_ifunc;
14841
14842   r_type = ELF64_R_TYPE (rela->r_info);
14843   switch (r_type)
14844     {
14845     case R_PPC64_RELATIVE:
14846       return reloc_class_relative;
14847     case R_PPC64_JMP_SLOT:
14848       return reloc_class_plt;
14849     case R_PPC64_COPY:
14850       return reloc_class_copy;
14851     default:
14852       return reloc_class_normal;
14853     }
14854 }
14855
14856 /* Finish up the dynamic sections.  */
14857
14858 static bfd_boolean
14859 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14860                                    struct bfd_link_info *info)
14861 {
14862   struct ppc_link_hash_table *htab;
14863   bfd *dynobj;
14864   asection *sdyn;
14865
14866   htab = ppc_hash_table (info);
14867   if (htab == NULL)
14868     return FALSE;
14869
14870   dynobj = htab->elf.dynobj;
14871   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14872
14873   if (htab->elf.dynamic_sections_created)
14874     {
14875       Elf64_External_Dyn *dyncon, *dynconend;
14876
14877       if (sdyn == NULL || htab->elf.sgot == NULL)
14878         abort ();
14879
14880       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14881       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14882       for (; dyncon < dynconend; dyncon++)
14883         {
14884           Elf_Internal_Dyn dyn;
14885           asection *s;
14886
14887           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14888
14889           switch (dyn.d_tag)
14890             {
14891             default:
14892               continue;
14893
14894             case DT_PPC64_GLINK:
14895               s = htab->glink;
14896               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14897               /* We stupidly defined DT_PPC64_GLINK to be the start
14898                  of glink rather than the first entry point, which is
14899                  what ld.so needs, and now have a bigger stub to
14900                  support automatic multiple TOCs.  */
14901               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14902               break;
14903
14904             case DT_PPC64_OPD:
14905               s = bfd_get_section_by_name (output_bfd, ".opd");
14906               if (s == NULL)
14907                 continue;
14908               dyn.d_un.d_ptr = s->vma;
14909               break;
14910
14911             case DT_PPC64_OPT:
14912               if (htab->do_multi_toc && htab->multi_toc_needed)
14913                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14914               break;
14915
14916             case DT_PPC64_OPDSZ:
14917               s = bfd_get_section_by_name (output_bfd, ".opd");
14918               if (s == NULL)
14919                 continue;
14920               dyn.d_un.d_val = s->size;
14921               break;
14922
14923             case DT_PLTGOT:
14924               s = htab->elf.splt;
14925               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14926               break;
14927
14928             case DT_JMPREL:
14929               s = htab->elf.srelplt;
14930               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14931               break;
14932
14933             case DT_PLTRELSZ:
14934               dyn.d_un.d_val = htab->elf.srelplt->size;
14935               break;
14936
14937             case DT_RELASZ:
14938               /* Don't count procedure linkage table relocs in the
14939                  overall reloc count.  */
14940               s = htab->elf.srelplt;
14941               if (s == NULL)
14942                 continue;
14943               dyn.d_un.d_val -= s->size;
14944               break;
14945
14946             case DT_RELA:
14947               /* We may not be using the standard ELF linker script.
14948                  If .rela.plt is the first .rela section, we adjust
14949                  DT_RELA to not include it.  */
14950               s = htab->elf.srelplt;
14951               if (s == NULL)
14952                 continue;
14953               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14954                 continue;
14955               dyn.d_un.d_ptr += s->size;
14956               break;
14957             }
14958
14959           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14960         }
14961     }
14962
14963   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14964     {
14965       /* Fill in the first entry in the global offset table.
14966          We use it to hold the link-time TOCbase.  */
14967       bfd_put_64 (output_bfd,
14968                   elf_gp (output_bfd) + TOC_BASE_OFF,
14969                   htab->elf.sgot->contents);
14970
14971       /* Set .got entry size.  */
14972       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14973     }
14974
14975   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14976     {
14977       /* Set .plt entry size.  */
14978       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14979         = PLT_ENTRY_SIZE (htab);
14980     }
14981
14982   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14983      brlt ourselves if emitrelocations.  */
14984   if (htab->brlt != NULL
14985       && htab->brlt->reloc_count != 0
14986       && !_bfd_elf_link_output_relocs (output_bfd,
14987                                        htab->brlt,
14988                                        elf_section_data (htab->brlt)->rela.hdr,
14989                                        elf_section_data (htab->brlt)->relocs,
14990                                        NULL))
14991     return FALSE;
14992
14993   if (htab->glink != NULL
14994       && htab->glink->reloc_count != 0
14995       && !_bfd_elf_link_output_relocs (output_bfd,
14996                                        htab->glink,
14997                                        elf_section_data (htab->glink)->rela.hdr,
14998                                        elf_section_data (htab->glink)->relocs,
14999                                        NULL))
15000     return FALSE;
15001
15002
15003   if (htab->glink_eh_frame != NULL
15004       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15005       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15006                                            htab->glink_eh_frame,
15007                                            htab->glink_eh_frame->contents))
15008     return FALSE;
15009
15010   /* We need to handle writing out multiple GOT sections ourselves,
15011      since we didn't add them to DYNOBJ.  We know dynobj is the first
15012      bfd.  */
15013   while ((dynobj = dynobj->link_next) != NULL)
15014     {
15015       asection *s;
15016
15017       if (!is_ppc64_elf (dynobj))
15018         continue;
15019
15020       s = ppc64_elf_tdata (dynobj)->got;
15021       if (s != NULL
15022           && s->size != 0
15023           && s->output_section != bfd_abs_section_ptr
15024           && !bfd_set_section_contents (output_bfd, s->output_section,
15025                                         s->contents, s->output_offset,
15026                                         s->size))
15027         return FALSE;
15028       s = ppc64_elf_tdata (dynobj)->relgot;
15029       if (s != NULL
15030           && s->size != 0
15031           && s->output_section != bfd_abs_section_ptr
15032           && !bfd_set_section_contents (output_bfd, s->output_section,
15033                                         s->contents, s->output_offset,
15034                                         s->size))
15035         return FALSE;
15036     }
15037
15038   return TRUE;
15039 }
15040
15041 #include "elf64-target.h"
15042
15043 /* FreeBSD support */
15044
15045 #undef  TARGET_LITTLE_SYM
15046 #undef  TARGET_LITTLE_NAME
15047
15048 #undef  TARGET_BIG_SYM
15049 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15050 #undef  TARGET_BIG_NAME
15051 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15052
15053 #undef  ELF_OSABI
15054 #define ELF_OSABI       ELFOSABI_FREEBSD
15055
15056 #undef  elf64_bed
15057 #define elf64_bed       elf64_powerpc_fbsd_bed
15058
15059 #include "elf64-target.h"
15060