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_signed, /* complain_on_overflow */
 361          ppc64_elf_branch_reloc, /* special_function */
 362          "R_PPC64_ADDR14",      /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0x0000fffc,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* An absolute 16 bit branch, for which bit 10 should be set to
 369      indicate that the branch is expected to be taken.  The lower two
 370      bits must be zero.  */
 371   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 372          0,                     /* rightshift */
 373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          16,                    /* bitsize */
 375          FALSE,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_signed, /* complain_on_overflow */
 378          ppc64_elf_brtaken_reloc, /* special_function */
 379          "R_PPC64_ADDR14_BRTAKEN",/* name */
 380          FALSE,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0x0000fffc,            /* dst_mask */
 383          FALSE),                /* pcrel_offset */
 384
 385   /* An absolute 16 bit branch, for which bit 10 should be set to
 386      indicate that the branch is not expected to be taken.  The lower
 387      two bits must be zero.  */
 388   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 389          0,                     /* rightshift */
 390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 391          16,                    /* bitsize */
 392          FALSE,                 /* pc_relative */
 393          0,                     /* bitpos */
 394          complain_overflow_signed, /* complain_on_overflow */
 395          ppc64_elf_brtaken_reloc, /* special_function */
 396          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 397          FALSE,                 /* partial_inplace */
 398          0,                     /* src_mask */
 399          0x0000fffc,            /* dst_mask */
 400          FALSE),                /* pcrel_offset */
 401
 402   /* A relative 26 bit branch; the lower two bits must be zero.  */
 403   HOWTO (R_PPC64_REL24,         /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          26,                    /* bitsize */
 407          TRUE,                  /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_branch_reloc, /* special_function */
 411          "R_PPC64_REL24",       /* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x03fffffc,            /* dst_mask */
 415          TRUE),                 /* pcrel_offset */
 416
 417   /* A relative 16 bit branch; the lower two bits must be zero.  */
 418   HOWTO (R_PPC64_REL14,         /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          16,                    /* bitsize */
 422          TRUE,                  /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          ppc64_elf_branch_reloc, /* special_function */
 426          "R_PPC64_REL14",       /* name */
 427          FALSE,                 /* partial_inplace */
 428          0,                     /* src_mask */
 429          0x0000fffc,            /* dst_mask */
 430          TRUE),                 /* pcrel_offset */
 431
 432   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 433      the branch is expected to be taken.  The lower two bits must be
 434      zero.  */
 435   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          16,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_brtaken_reloc, /* special_function */
 443          "R_PPC64_REL14_BRTAKEN", /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x0000fffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 450      the branch is not expected to be taken.  The lower two bits must
 451      be zero.  */
 452   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 453          0,                     /* rightshift */
 454          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          16,                    /* bitsize */
 456          TRUE,                  /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_signed, /* complain_on_overflow */
 459          ppc64_elf_brtaken_reloc, /* special_function */
 460          "R_PPC64_REL14_BRNTAKEN",/* name */
 461          FALSE,                 /* partial_inplace */
 462          0,                     /* src_mask */
 463          0x0000fffc,            /* dst_mask */
 464          TRUE),                 /* pcrel_offset */
 465
 466   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 467      symbol.  */
 468   HOWTO (R_PPC64_GOT16,         /* type */
 469          0,                     /* rightshift */
 470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_signed, /* complain_on_overflow */
 475          ppc64_elf_unhandled_reloc, /* special_function */
 476          "R_PPC64_GOT16",       /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0xffff,                /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 483      the symbol.  */
 484   HOWTO (R_PPC64_GOT16_LO,      /* type */
 485          0,                     /* rightshift */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont, /* complain_on_overflow */
 491          ppc64_elf_unhandled_reloc, /* special_function */
 492          "R_PPC64_GOT16_LO",    /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0xffff,                /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 499      the symbol.  */
 500   HOWTO (R_PPC64_GOT16_HI,      /* type */
 501          16,                    /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed,/* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16_HI",    /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_HA,      /* type */
 517          16,                    /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_signed,/* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_HA",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* This is used only by the dynamic linker.  The symbol should exist
 531      both in the object being run and in some shared library.  The
 532      dynamic linker copies the data addressed by the symbol from the
 533      shared library into the object, because the object being
 534      run has to have the data at some particular address.  */
 535   HOWTO (R_PPC64_COPY,          /* type */
 536          0,                     /* rightshift */
 537          0,                     /* this one is variable size */
 538          0,                     /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_dont, /* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc, /* special_function */
 543          "R_PPC64_COPY",        /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          0,                     /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* Like R_PPC64_ADDR64, but used when setting global offset table
 550      entries.  */
 551   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 552          0,                     /* rightshift */
 553          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 554          64,                    /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont, /* complain_on_overflow */
 558          ppc64_elf_unhandled_reloc,  /* special_function */
 559          "R_PPC64_GLOB_DAT",    /* name */
 560          FALSE,                 /* partial_inplace */
 561          0,                     /* src_mask */
 562          ONES (64),             /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564
 565   /* Created by the link editor.  Marks a procedure linkage table
 566      entry for a symbol.  */
 567   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 568          0,                     /* rightshift */
 569          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_JMP_SLOT",    /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Used only by the dynamic linker.  When the object is run, this
 582      doubleword64 is set to the load address of the object, plus the
 583      addend.  */
 584   HOWTO (R_PPC64_RELATIVE,      /* type */
 585          0,                     /* rightshift */
 586          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 587          64,                    /* bitsize */
 588          FALSE,                 /* pc_relative */
 589          0,                     /* bitpos */
 590          complain_overflow_dont, /* complain_on_overflow */
 591          bfd_elf_generic_reloc, /* special_function */
 592          "R_PPC64_RELATIVE",    /* name */
 593          FALSE,                 /* partial_inplace */
 594          0,                     /* src_mask */
 595          ONES (64),             /* dst_mask */
 596          FALSE),                /* pcrel_offset */
 597
 598   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 599   HOWTO (R_PPC64_UADDR32,       /* type */
 600          0,                     /* rightshift */
 601          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          32,                    /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_bitfield, /* complain_on_overflow */
 606          bfd_elf_generic_reloc, /* special_function */
 607          "R_PPC64_UADDR32",     /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0xffffffff,            /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 614   HOWTO (R_PPC64_UADDR16,       /* type */
 615          0,                     /* rightshift */
 616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 617          16,                    /* bitsize */
 618          FALSE,                 /* pc_relative */
 619          0,                     /* bitpos */
 620          complain_overflow_bitfield, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_UADDR16",     /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffff,                /* dst_mask */
 626          FALSE),                /* pcrel_offset */
 627
 628   /* 32-bit PC relative.  */
 629   HOWTO (R_PPC64_REL32,         /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          TRUE,                  /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_signed, /* complain_on_overflow */
 636          bfd_elf_generic_reloc, /* special_function */
 637          "R_PPC64_REL32",       /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          TRUE),                 /* pcrel_offset */
 642
 643   /* 32-bit relocation to the symbol's procedure linkage table.  */
 644   HOWTO (R_PPC64_PLT32,         /* type */
 645          0,                     /* rightshift */
 646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          32,                    /* bitsize */
 648          FALSE,                 /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_bitfield, /* complain_on_overflow */
 651          ppc64_elf_unhandled_reloc, /* special_function */
 652          "R_PPC64_PLT32",       /* name */
 653          FALSE,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffffffff,            /* dst_mask */
 656          FALSE),                /* pcrel_offset */
 657
 658   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 659      FIXME: R_PPC64_PLTREL32 not supported.  */
 660   HOWTO (R_PPC64_PLTREL32,      /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          32,                    /* bitsize */
 664          TRUE,                  /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_signed, /* complain_on_overflow */
 667          bfd_elf_generic_reloc, /* special_function */
 668          "R_PPC64_PLTREL32",    /* name */
 669          FALSE,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0xffffffff,            /* dst_mask */
 672          TRUE),                 /* pcrel_offset */
 673
 674   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 675      the symbol.  */
 676   HOWTO (R_PPC64_PLT16_LO,      /* type */
 677          0,                     /* rightshift */
 678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          16,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_dont, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT16_LO",    /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffff,                /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 691      the symbol.  */
 692   HOWTO (R_PPC64_PLT16_HI,      /* type */
 693          16,                    /* rightshift */
 694          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          16,                    /* bitsize */
 696          FALSE,                 /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLT16_HI",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffff,                /* dst_mask */
 704          FALSE),                /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_HA,      /* type */
 709          16,                    /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_signed, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_HA",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* 16-bit section relative relocation.  */
 723   HOWTO (R_PPC64_SECTOFF,       /* type */
 724          0,                     /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_signed, /* complain_on_overflow */
 730          ppc64_elf_sectoff_reloc, /* special_function */
 731          "R_PPC64_SECTOFF",     /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 738   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 739          0,                     /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF_LO",  /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit upper half section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 754          16,                    /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_signed, /* complain_on_overflow */
 760          ppc64_elf_sectoff_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_HI",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* 16-bit upper half adjusted section relative relocation.  */
 768   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 769          16,                    /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_signed, /* complain_on_overflow */
 775          ppc64_elf_sectoff_ha_reloc, /* special_function */
 776          "R_PPC64_SECTOFF_HA",  /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 783   HOWTO (R_PPC64_REL30,         /* type */
 784          2,                     /* rightshift */
 785          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          30,                    /* bitsize */
 787          TRUE,                  /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_dont, /* complain_on_overflow */
 790          bfd_elf_generic_reloc, /* special_function */
 791          "R_PPC64_REL30",       /* name */
 792          FALSE,                 /* partial_inplace */
 793          0,                     /* src_mask */
 794          0xfffffffc,            /* dst_mask */
 795          TRUE),                 /* pcrel_offset */
 796
 797   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 798
 799   /* A standard 64-bit relocation.  */
 800   HOWTO (R_PPC64_ADDR64,        /* type */
 801          0,                     /* rightshift */
 802          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 803          64,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_PPC64_ADDR64",      /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          ONES (64),             /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* The bits 32-47 of an address.  */
 815   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 816          32,                    /* rightshift */
 817          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          16,                    /* bitsize */
 819          FALSE,                 /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_ADDR16_HIGHER", /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xffff,                /* dst_mask */
 827          FALSE),                /* pcrel_offset */
 828
 829   /* The bits 32-47 of an address, plus 1 if the contents of the low
 830      16 bits, treated as a signed number, is negative.  */
 831   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 832          32,                    /* rightshift */
 833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 834          16,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          ppc64_elf_ha_reloc,    /* special_function */
 839          "R_PPC64_ADDR16_HIGHERA", /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          0xffff,                /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 48-63 of an address.  */
 846   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 847          48,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_dont, /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_PPC64_ADDR16_HIGHEST", /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* The bits 48-63 of an address, plus 1 if the contents of the low
 861      16 bits, treated as a signed number, is negative.  */
 862   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 863          48,                    /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          ppc64_elf_ha_reloc,    /* special_function */
 870          "R_PPC64_ADDR16_HIGHESTA", /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* Like ADDR64, but may be unaligned.  */
 877   HOWTO (R_PPC64_UADDR64,       /* type */
 878          0,                     /* rightshift */
 879          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 880          64,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_UADDR64",     /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          ONES (64),             /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* 64-bit relative relocation.  */
 892   HOWTO (R_PPC64_REL64,         /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          TRUE,                  /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_PPC64_REL64",       /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          TRUE),                 /* pcrel_offset */
 905
 906   /* 64-bit relocation to the symbol's procedure linkage table.  */
 907   HOWTO (R_PPC64_PLT64,         /* type */
 908          0,                     /* rightshift */
 909          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 910          64,                    /* bitsize */
 911          FALSE,                 /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont, /* complain_on_overflow */
 914          ppc64_elf_unhandled_reloc, /* special_function */
 915          "R_PPC64_PLT64",       /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          ONES (64),             /* dst_mask */
 919          FALSE),                /* pcrel_offset */
 920
 921   /* 64-bit PC relative relocation to the symbol's procedure linkage
 922      table.  */
 923   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 924   HOWTO (R_PPC64_PLTREL64,      /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          ppc64_elf_unhandled_reloc, /* special_function */
 932          "R_PPC64_PLTREL64",    /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 16 bit TOC-relative relocation.  */
 939
 940   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 941   HOWTO (R_PPC64_TOC16,         /* type */
 942          0,                     /* rightshift */
 943          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 944          16,                    /* bitsize */
 945          FALSE,                 /* pc_relative */
 946          0,                     /* bitpos */
 947          complain_overflow_signed, /* complain_on_overflow */
 948          ppc64_elf_toc_reloc,   /* special_function */
 949          "R_PPC64_TOC16",       /* name */
 950          FALSE,                 /* partial_inplace */
 951          0,                     /* src_mask */
 952          0xffff,                /* dst_mask */
 953          FALSE),                /* pcrel_offset */
 954
 955   /* 16 bit TOC-relative relocation without overflow.  */
 956
 957   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 958   HOWTO (R_PPC64_TOC16_LO,      /* type */
 959          0,                     /* rightshift */
 960          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 961          16,                    /* bitsize */
 962          FALSE,                 /* pc_relative */
 963          0,                     /* bitpos */
 964          complain_overflow_dont, /* complain_on_overflow */
 965          ppc64_elf_toc_reloc,   /* special_function */
 966          "R_PPC64_TOC16_LO",    /* name */
 967          FALSE,                 /* partial_inplace */
 968          0,                     /* src_mask */
 969          0xffff,                /* dst_mask */
 970          FALSE),                /* pcrel_offset */
 971
 972   /* 16 bit TOC-relative relocation, high 16 bits.  */
 973
 974   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 975   HOWTO (R_PPC64_TOC16_HI,      /* type */
 976          16,                    /* rightshift */
 977          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 978          16,                    /* bitsize */
 979          FALSE,                 /* pc_relative */
 980          0,                     /* bitpos */
 981          complain_overflow_signed, /* complain_on_overflow */
 982          ppc64_elf_toc_reloc,   /* special_function */
 983          "R_PPC64_TOC16_HI",    /* name */
 984          FALSE,                 /* partial_inplace */
 985          0,                     /* src_mask */
 986          0xffff,                /* dst_mask */
 987          FALSE),                /* pcrel_offset */
 988
 989   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 990      contents of the low 16 bits, treated as a signed number, is
 991      negative.  */
 992
 993   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 994   HOWTO (R_PPC64_TOC16_HA,      /* type */
 995          16,                    /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_toc_ha_reloc, /* special_function */
1002          "R_PPC64_TOC16_HA",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1009
1010   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1011   HOWTO (R_PPC64_TOC,           /* type */
1012          0,                     /* rightshift */
1013          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1014          64,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_dont, /* complain_on_overflow */
1018          ppc64_elf_toc64_reloc, /* special_function */
1019          "R_PPC64_TOC",         /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          ONES (64),             /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_GOT16, but also informs the link editor that the
1026      value to relocate may (!) refer to a PLT entry which the link
1027      editor (a) may replace with the symbol value.  If the link editor
1028      is unable to fully resolve the symbol, it may (b) create a PLT
1029      entry and store the address to the new PLT entry in the GOT.
1030      This permits lazy resolution of function symbols at run time.
1031      The link editor may also skip all of this and just (c) emit a
1032      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1033   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1034     HOWTO (R_PPC64_PLTGOT16,    /* type */
1035          0,                     /* rightshift */
1036          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1037          16,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_signed, /* complain_on_overflow */
1041          ppc64_elf_unhandled_reloc, /* special_function */
1042          "R_PPC64_PLTGOT16",    /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          0xffff,                /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1049   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1050   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1051          0,                     /* rightshift */
1052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1053          16,                    /* bitsize */
1054          FALSE,                 /* pc_relative */
1055          0,                     /* bitpos */
1056          complain_overflow_dont, /* complain_on_overflow */
1057          ppc64_elf_unhandled_reloc, /* special_function */
1058          "R_PPC64_PLTGOT16_LO", /* name */
1059          FALSE,                 /* partial_inplace */
1060          0,                     /* src_mask */
1061          0xffff,                /* dst_mask */
1062          FALSE),                /* pcrel_offset */
1063
1064   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1065   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1066   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1067          16,                    /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16_HI", /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1081      1 if the contents of the low 16 bits, treated as a signed number,
1082      is negative.  */
1083   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1084   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1085          16,                    /* rightshift */
1086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          16,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_signed, /* complain_on_overflow */
1091          ppc64_elf_unhandled_reloc, /* special_function */
1092          "R_PPC64_PLTGOT16_HA", /* name */
1093          FALSE,                 /* partial_inplace */
1094          0,                     /* src_mask */
1095          0xffff,                /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1099   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1100          0,                     /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_signed, /* complain_on_overflow */
1106          bfd_elf_generic_reloc, /* special_function */
1107          "R_PPC64_ADDR16_DS",   /* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xfffc,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_dont,/* complain_on_overflow */
1121          bfd_elf_generic_reloc, /* special_function */
1122          "R_PPC64_ADDR16_LO_DS",/* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_GOT16_DS,      /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_signed, /* complain_on_overflow */
1136          ppc64_elf_unhandled_reloc, /* special_function */
1137          "R_PPC64_GOT16_DS",    /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_GOT16_LO_DS", /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_dont, /* complain_on_overflow */
1166          ppc64_elf_unhandled_reloc, /* special_function */
1167          "R_PPC64_PLT16_LO_DS", /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_signed, /* complain_on_overflow */
1181          ppc64_elf_sectoff_reloc, /* special_function */
1182          "R_PPC64_SECTOFF_DS",  /* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont, /* complain_on_overflow */
1196          ppc64_elf_sectoff_reloc, /* special_function */
1197          "R_PPC64_SECTOFF_LO_DS",/* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_TOC16_DS,      /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_signed, /* complain_on_overflow */
1211          ppc64_elf_toc_reloc,   /* special_function */
1212          "R_PPC64_TOC16_DS",    /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1219   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1220          0,                     /* rightshift */
1221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          16,                    /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont, /* complain_on_overflow */
1226          ppc64_elf_toc_reloc,   /* special_function */
1227          "R_PPC64_TOC16_LO_DS", /* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0xfffc,                /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1234   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1235   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1236          0,                     /* rightshift */
1237          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1238          16,                    /* bitsize */
1239          FALSE,                 /* pc_relative */
1240          0,                     /* bitpos */
1241          complain_overflow_signed, /* complain_on_overflow */
1242          ppc64_elf_unhandled_reloc, /* special_function */
1243          "R_PPC64_PLTGOT16_DS", /* name */
1244          FALSE,                 /* partial_inplace */
1245          0,                     /* src_mask */
1246          0xfffc,                /* dst_mask */
1247          FALSE),                /* pcrel_offset */
1248
1249   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1250   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1251   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_unhandled_reloc, /* special_function */
1259          "R_PPC64_PLTGOT16_LO_DS",/* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Marker relocs for TLS.  */
1266   HOWTO (R_PPC64_TLS,
1267          0,                     /* rightshift */
1268          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          32,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_dont, /* complain_on_overflow */
1273          bfd_elf_generic_reloc, /* special_function */
1274          "R_PPC64_TLS",         /* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0,                     /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   HOWTO (R_PPC64_TLSGD,
1281          0,                     /* rightshift */
1282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1283          32,                    /* bitsize */
1284          FALSE,                 /* pc_relative */
1285          0,                     /* bitpos */
1286          complain_overflow_dont, /* complain_on_overflow */
1287          bfd_elf_generic_reloc, /* special_function */
1288          "R_PPC64_TLSGD",       /* name */
1289          FALSE,                 /* partial_inplace */
1290          0,                     /* src_mask */
1291          0,                     /* dst_mask */
1292          FALSE),                /* pcrel_offset */
1293
1294   HOWTO (R_PPC64_TLSLD,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLSLD",       /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TOCSAVE,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TOCSAVE",     /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   /* Computes the load module index of the load module that contains the
1323      definition of its TLS sym.  */
1324   HOWTO (R_PPC64_DTPMOD64,
1325          0,                     /* rightshift */
1326          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1327          64,                    /* bitsize */
1328          FALSE,                 /* pc_relative */
1329          0,                     /* bitpos */
1330          complain_overflow_dont, /* complain_on_overflow */
1331          ppc64_elf_unhandled_reloc, /* special_function */
1332          "R_PPC64_DTPMOD64",    /* name */
1333          FALSE,                 /* partial_inplace */
1334          0,                     /* src_mask */
1335          ONES (64),             /* dst_mask */
1336          FALSE),                /* pcrel_offset */
1337
1338   /* Computes a dtv-relative displacement, the difference between the value
1339      of sym+add and the base address of the thread-local storage block that
1340      contains the definition of sym, minus 0x8000.  */
1341   HOWTO (R_PPC64_DTPREL64,
1342          0,                     /* rightshift */
1343          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          64,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont, /* complain_on_overflow */
1348          ppc64_elf_unhandled_reloc, /* special_function */
1349          "R_PPC64_DTPREL64",    /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          ONES (64),             /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* A 16 bit dtprel reloc.  */
1356   HOWTO (R_PPC64_DTPREL16,
1357          0,                     /* rightshift */
1358          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          16,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_signed, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL16",    /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0xffff,                /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* Like DTPREL16, but no overflow.  */
1371   HOWTO (R_PPC64_DTPREL16_LO,
1372          0,                     /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16_LO", /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1386   HOWTO (R_PPC64_DTPREL16_HI,
1387          16,                    /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_signed, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_HI", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HA,
1402          16,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_signed, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HA", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HIGHER,
1417          32,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_dont, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HIGHER", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1432          32,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHERA", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1447          48,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHEST", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1461   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1462          48,                    /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_dont, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xffff,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16, but for insns with a DS field.  */
1476   HOWTO (R_PPC64_DTPREL16_DS,
1477          0,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_signed, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_DS", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xfffc,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Like DTPREL16_DS, but no overflow.  */
1491   HOWTO (R_PPC64_DTPREL16_LO_DS,
1492          0,                     /* rightshift */
1493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          16,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_dont, /* complain_on_overflow */
1498          ppc64_elf_unhandled_reloc, /* special_function */
1499          "R_PPC64_DTPREL16_LO_DS", /* name */
1500          FALSE,                 /* partial_inplace */
1501          0,                     /* src_mask */
1502          0xfffc,                /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   /* Computes a tp-relative displacement, the difference between the value of
1506      sym+add and the value of the thread pointer (r13).  */
1507   HOWTO (R_PPC64_TPREL64,
1508          0,                     /* rightshift */
1509          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          64,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_dont, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_TPREL64",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          ONES (64),             /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* A 16 bit tprel reloc.  */
1522   HOWTO (R_PPC64_TPREL16,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_signed, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL16",     /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Like TPREL16, but no overflow.  */
1537   HOWTO (R_PPC64_TPREL16_LO,
1538          0,                     /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16_LO",  /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1552   HOWTO (R_PPC64_TPREL16_HI,
1553          16,                    /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_signed, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_HI",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HA,
1568          16,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_signed, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HA",  /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HIGHER,
1583          32,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_dont, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HIGHER",      /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHERA,
1598          32,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHERA", /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHEST,
1613          48,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHEST", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1627   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1628          48,                    /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_dont, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_HIGHESTA", /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xffff,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16, but for insns with a DS field.  */
1642   HOWTO (R_PPC64_TPREL16_DS,
1643          0,                     /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_signed, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_DS",  /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xfffc,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Like TPREL16_DS, but no overflow.  */
1657   HOWTO (R_PPC64_TPREL16_LO_DS,
1658          0,                     /* rightshift */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1660          16,                    /* bitsize */
1661          FALSE,                 /* pc_relative */
1662          0,                     /* bitpos */
1663          complain_overflow_dont, /* complain_on_overflow */
1664          ppc64_elf_unhandled_reloc, /* special_function */
1665          "R_PPC64_TPREL16_LO_DS", /* name */
1666          FALSE,                 /* partial_inplace */
1667          0,                     /* src_mask */
1668          0xfffc,                /* dst_mask */
1669          FALSE),                /* pcrel_offset */
1670
1671   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1672      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1673      to the first entry relative to the TOC base (r2).  */
1674   HOWTO (R_PPC64_GOT_TLSGD16,
1675          0,                     /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_signed, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_GOT_TLSGD16", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like GOT_TLSGD16, but no overflow.  */
1689   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1690          0,                     /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16_LO", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1705          16,                    /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_signed, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_HI", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1719   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1720          16,                    /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          FALSE,                 /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_signed, /* complain_on_overflow */
1726          ppc64_elf_unhandled_reloc, /* special_function */
1727          "R_PPC64_GOT_TLSGD16_HA", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1734      with values (sym+add)@dtpmod and zero, and computes the offset to the
1735      first entry relative to the TOC base (r2).  */
1736   HOWTO (R_PPC64_GOT_TLSLD16,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_signed, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSLD16", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSLD16, but no overflow.  */
1751   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16_LO", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1767          16,                    /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_signed, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_HI", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1781   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1782          16,                    /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_signed, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSLD16_HA", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1796      the offset to the entry relative to the TOC base (r2).  */
1797   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1798          0,                     /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_signed, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_DTPREL16_DS", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xfffc,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_DTPREL16_DS, but no overflow.  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1813          0,                     /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_dont, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xfffc,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1828          16,                    /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_signed, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_HI", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xffff,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1842   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1843          16,                    /* rightshift */
1844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1845          16,                    /* bitsize */
1846          FALSE,                 /* pc_relative */
1847          0,                     /* bitpos */
1848          complain_overflow_signed, /* complain_on_overflow */
1849          ppc64_elf_unhandled_reloc, /* special_function */
1850          "R_PPC64_GOT_DTPREL16_HA", /* name */
1851          FALSE,                 /* partial_inplace */
1852          0,                     /* src_mask */
1853          0xffff,                /* dst_mask */
1854          FALSE),                /* pcrel_offset */
1855
1856   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1857      offset to the entry relative to the TOC base (r2).  */
1858   HOWTO (R_PPC64_GOT_TPREL16_DS,
1859          0,                     /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_signed, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_TPREL16_DS", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xfffc,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_TPREL16_DS, but no overflow.  */
1873   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1874          0,                     /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_dont, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xfffc,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_HI,
1889          16,                    /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_signed, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_HI", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xffff,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1903   HOWTO (R_PPC64_GOT_TPREL16_HA,
1904          16,                    /* rightshift */
1905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1906          16,                    /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_signed, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_GOT_TPREL16_HA", /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0xffff,                /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   HOWTO (R_PPC64_JMP_IREL,      /* type */
1918          0,                     /* rightshift */
1919          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1920          0,                     /* bitsize */
1921          FALSE,                 /* pc_relative */
1922          0,                     /* bitpos */
1923          complain_overflow_dont, /* complain_on_overflow */
1924          ppc64_elf_unhandled_reloc, /* special_function */
1925          "R_PPC64_JMP_IREL",    /* name */
1926          FALSE,                 /* partial_inplace */
1927          0,                     /* src_mask */
1928          0,                     /* dst_mask */
1929          FALSE),                /* pcrel_offset */
1930
1931   HOWTO (R_PPC64_IRELATIVE,     /* type */
1932          0,                     /* rightshift */
1933          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1934          64,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_dont, /* complain_on_overflow */
1938          bfd_elf_generic_reloc, /* special_function */
1939          "R_PPC64_IRELATIVE",   /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          ONES (64),             /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   /* A 16 bit relative relocation.  */
1946   HOWTO (R_PPC64_REL16,         /* type */
1947          0,                     /* rightshift */
1948          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1949          16,                    /* bitsize */
1950          TRUE,                  /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_signed, /* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_REL16",       /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          0xffff,                /* dst_mask */
1958          TRUE),                 /* pcrel_offset */
1959
1960   /* A 16 bit relative relocation without overflow.  */
1961   HOWTO (R_PPC64_REL16_LO,      /* type */
1962          0,                     /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont,/* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16_LO",    /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* The high order 16 bits of a relative address.  */
1976   HOWTO (R_PPC64_REL16_HI,      /* type */
1977          16,                    /* rightshift */
1978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1979          16,                    /* bitsize */
1980          TRUE,                  /* pc_relative */
1981          0,                     /* bitpos */
1982          complain_overflow_signed, /* complain_on_overflow */
1983          bfd_elf_generic_reloc, /* special_function */
1984          "R_PPC64_REL16_HI",    /* name */
1985          FALSE,                 /* partial_inplace */
1986          0,                     /* src_mask */
1987          0xffff,                /* dst_mask */
1988          TRUE),                 /* pcrel_offset */
1989
1990   /* The high order 16 bits of a relative address, plus 1 if the contents of
1991      the low 16 bits, treated as a signed number, is negative.  */
1992   HOWTO (R_PPC64_REL16_HA,      /* type */
1993          16,                    /* rightshift */
1994          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          16,                    /* bitsize */
1996          TRUE,                  /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_signed, /* complain_on_overflow */
1999          ppc64_elf_ha_reloc,    /* special_function */
2000          "R_PPC64_REL16_HA",    /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0xffff,                /* dst_mask */
2004          TRUE),                 /* pcrel_offset */
2005
2006   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2007   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2008          16,                    /* rightshift */
2009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          16,                    /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont, /* complain_on_overflow */
2014          bfd_elf_generic_reloc, /* special_function */
2015          "R_PPC64_ADDR16_HIGH", /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0xffff,                /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020
2021   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2022   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2023          16,                    /* rightshift */
2024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2025          16,                    /* bitsize */
2026          FALSE,                 /* pc_relative */
2027          0,                     /* bitpos */
2028          complain_overflow_dont, /* complain_on_overflow */
2029          ppc64_elf_ha_reloc,    /* special_function */
2030          "R_PPC64_ADDR16_HIGHA",        /* name */
2031          FALSE,                 /* partial_inplace */
2032          0,                     /* src_mask */
2033          0xffff,                /* dst_mask */
2034          FALSE),                /* pcrel_offset */
2035
2036   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2037   HOWTO (R_PPC64_DTPREL16_HIGH,
2038          16,                    /* rightshift */
2039          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2040          16,                    /* bitsize */
2041          FALSE,                 /* pc_relative */
2042          0,                     /* bitpos */
2043          complain_overflow_dont, /* complain_on_overflow */
2044          ppc64_elf_unhandled_reloc, /* special_function */
2045          "R_PPC64_DTPREL16_HIGH", /* name */
2046          FALSE,                 /* partial_inplace */
2047          0,                     /* src_mask */
2048          0xffff,                /* dst_mask */
2049          FALSE),                /* pcrel_offset */
2050
2051   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2052   HOWTO (R_PPC64_DTPREL16_HIGHA,
2053          16,                    /* rightshift */
2054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2055          16,                    /* bitsize */
2056          FALSE,                 /* pc_relative */
2057          0,                     /* bitpos */
2058          complain_overflow_dont, /* complain_on_overflow */
2059          ppc64_elf_unhandled_reloc, /* special_function */
2060          "R_PPC64_DTPREL16_HIGHA", /* name */
2061          FALSE,                 /* partial_inplace */
2062          0,                     /* src_mask */
2063          0xffff,                /* dst_mask */
2064          FALSE),                /* pcrel_offset */
2065
2066   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2067   HOWTO (R_PPC64_TPREL16_HIGH,
2068          16,                    /* rightshift */
2069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2070          16,                    /* bitsize */
2071          FALSE,                 /* pc_relative */
2072          0,                     /* bitpos */
2073          complain_overflow_dont, /* complain_on_overflow */
2074          ppc64_elf_unhandled_reloc, /* special_function */
2075          "R_PPC64_TPREL16_HIGH",        /* name */
2076          FALSE,                 /* partial_inplace */
2077          0,                     /* src_mask */
2078          0xffff,                /* dst_mask */
2079          FALSE),                /* pcrel_offset */
2080
2081   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2082   HOWTO (R_PPC64_TPREL16_HIGHA,
2083          16,                    /* rightshift */
2084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2085          16,                    /* bitsize */
2086          FALSE,                 /* pc_relative */
2087          0,                     /* bitpos */
2088          complain_overflow_dont, /* complain_on_overflow */
2089          ppc64_elf_unhandled_reloc, /* special_function */
2090          "R_PPC64_TPREL16_HIGHA",       /* name */
2091          FALSE,                 /* partial_inplace */
2092          0,                     /* src_mask */
2093          0xffff,                /* dst_mask */
2094          FALSE),                /* pcrel_offset */
2095
2096   /* Like ADDR64, but use local entry point of function.  */
2097   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2098          0,                     /* rightshift */
2099          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2100          64,                    /* bitsize */
2101          FALSE,                 /* pc_relative */
2102          0,                     /* bitpos */
2103          complain_overflow_dont, /* complain_on_overflow */
2104          bfd_elf_generic_reloc, /* special_function */
2105          "R_PPC64_ADDR64_LOCAL", /* name */
2106          FALSE,                 /* partial_inplace */
2107          0,                     /* src_mask */
2108          ONES (64),             /* dst_mask */
2109          FALSE),                /* pcrel_offset */
2110
2111   /* GNU extension to record C++ vtable hierarchy.  */
2112   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2113          0,                     /* rightshift */
2114          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2115          0,                     /* bitsize */
2116          FALSE,                 /* pc_relative */
2117          0,                     /* bitpos */
2118          complain_overflow_dont, /* complain_on_overflow */
2119          NULL,                  /* special_function */
2120          "R_PPC64_GNU_VTINHERIT", /* name */
2121          FALSE,                 /* partial_inplace */
2122          0,                     /* src_mask */
2123          0,                     /* dst_mask */
2124          FALSE),                /* pcrel_offset */
2125
2126   /* GNU extension to record C++ vtable member usage.  */
2127   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2128          0,                     /* rightshift */
2129          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2130          0,                     /* bitsize */
2131          FALSE,                 /* pc_relative */
2132          0,                     /* bitpos */
2133          complain_overflow_dont, /* complain_on_overflow */
2134          NULL,                  /* special_function */
2135          "R_PPC64_GNU_VTENTRY", /* name */
2136          FALSE,                 /* partial_inplace */
2137          0,                     /* src_mask */
2138          0,                     /* dst_mask */
2139          FALSE),                /* pcrel_offset */
2140 };
2141
2142 \f
2143 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2144    be done.  */
2145
2146 static void
2147 ppc_howto_init (void)
2148 {
2149   unsigned int i, type;
2150
2151   for (i = 0;
2152        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2153        i++)
2154     {
2155       type = ppc64_elf_howto_raw[i].type;
2156       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2157                           / sizeof (ppc64_elf_howto_table[0])));
2158       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2159     }
2160 }
2161
2162 static reloc_howto_type *
2163 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2164                              bfd_reloc_code_real_type code)
2165 {
2166   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2167
2168   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2169     /* Initialize howto table if needed.  */
2170     ppc_howto_init ();
2171
2172   switch (code)
2173     {
2174     default:
2175       return NULL;
2176
2177     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2178       break;
2179     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2180       break;
2181     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2182       break;
2183     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2184       break;
2185     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2186       break;
2187     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2188       break;
2189     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2190       break;
2191     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2192       break;
2193     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2194       break;
2195     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2196       break;
2197     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2198       break;
2199     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2200       break;
2201     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2202       break;
2203     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2204       break;
2205     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2206       break;
2207     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2208       break;
2209     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2210       break;
2211     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2212       break;
2213     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2214       break;
2215     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2216       break;
2217     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2218       break;
2219     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2220       break;
2221     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2222       break;
2223     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2224       break;
2225     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2226       break;
2227     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2228       break;
2229     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2230       break;
2231     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2232       break;
2233     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2234       break;
2235     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2236       break;
2237     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2238       break;
2239     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2240       break;
2241     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2242       break;
2243     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2244       break;
2245     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2246       break;
2247     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2248       break;
2249     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2250       break;
2251     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2252       break;
2253     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2254       break;
2255     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2256       break;
2257     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2258       break;
2259     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2260       break;
2261     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2262       break;
2263     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2264       break;
2265     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2266       break;
2267     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2268       break;
2269     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2270       break;
2271     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2272       break;
2273     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2274       break;
2275     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2276       break;
2277     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2278       break;
2279     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2280       break;
2281     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2282       break;
2283     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2284       break;
2285     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2286       break;
2287     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2288       break;
2289     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2290       break;
2291     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2292       break;
2293     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2294       break;
2295     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2296       break;
2297     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2298       break;
2299     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2300       break;
2301     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2302       break;
2303     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2304       break;
2305     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2306       break;
2307     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2308       break;
2309     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2310       break;
2311     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2312       break;
2313     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2314       break;
2315     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2318       break;
2319     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2320       break;
2321     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2322       break;
2323     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2324       break;
2325     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2326       break;
2327     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2328       break;
2329     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2330       break;
2331     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2332       break;
2333     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2334       break;
2335     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2336       break;
2337     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2338       break;
2339     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2340       break;
2341     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2342       break;
2343     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2344       break;
2345     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2346       break;
2347     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2348       break;
2349     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2350       break;
2351     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2352       break;
2353     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2356       break;
2357     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2358       break;
2359     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2360       break;
2361     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2362       break;
2363     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2364       break;
2365     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2368       break;
2369     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2370       break;
2371     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2372       break;
2373     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2374       break;
2375     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2376       break;
2377     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2378       break;
2379     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2382       break;
2383     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2384       break;
2385     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2386       break;
2387     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2388       break;
2389     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2390       break;
2391     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2392       break;
2393     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2394       break;
2395     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2396       break;
2397     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2398       break;
2399     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2400       break;
2401     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2402       break;
2403     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2404       break;
2405     }
2406
2407   return ppc64_elf_howto_table[r];
2408 };
2409
2410 static reloc_howto_type *
2411 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2412                              const char *r_name)
2413 {
2414   unsigned int i;
2415
2416   for (i = 0;
2417        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2418        i++)
2419     if (ppc64_elf_howto_raw[i].name != NULL
2420         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2421       return &ppc64_elf_howto_raw[i];
2422
2423   return NULL;
2424 }
2425
2426 /* Set the howto pointer for a PowerPC ELF reloc.  */
2427
2428 static void
2429 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2430                          Elf_Internal_Rela *dst)
2431 {
2432   unsigned int type;
2433
2434   /* Initialize howto table if needed.  */
2435   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2436     ppc_howto_init ();
2437
2438   type = ELF64_R_TYPE (dst->r_info);
2439   if (type >= (sizeof (ppc64_elf_howto_table)
2440                / sizeof (ppc64_elf_howto_table[0])))
2441     {
2442       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2443                              abfd, (int) type);
2444       type = R_PPC64_NONE;
2445     }
2446   cache_ptr->howto = ppc64_elf_howto_table[type];
2447 }
2448
2449 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2450
2451 static bfd_reloc_status_type
2452 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453                     void *data, asection *input_section,
2454                     bfd *output_bfd, char **error_message)
2455 {
2456   /* If this is a relocatable link (output_bfd test tells us), just
2457      call the generic function.  Any adjustment will be done at final
2458      link time.  */
2459   if (output_bfd != NULL)
2460     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2461                                   input_section, output_bfd, error_message);
2462
2463   /* Adjust the addend for sign extension of the low 16 bits.
2464      We won't actually be using the low 16 bits, so trashing them
2465      doesn't matter.  */
2466   reloc_entry->addend += 0x8000;
2467   return bfd_reloc_continue;
2468 }
2469
2470 static bfd_reloc_status_type
2471 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2472                         void *data, asection *input_section,
2473                         bfd *output_bfd, char **error_message)
2474 {
2475   if (output_bfd != NULL)
2476     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2477                                   input_section, output_bfd, error_message);
2478
2479   if (strcmp (symbol->section->name, ".opd") == 0
2480       && (symbol->section->owner->flags & DYNAMIC) == 0)
2481     {
2482       bfd_vma dest = opd_entry_value (symbol->section,
2483                                       symbol->value + reloc_entry->addend,
2484                                       NULL, NULL, FALSE);
2485       if (dest != (bfd_vma) -1)
2486         reloc_entry->addend = dest - (symbol->value
2487                                       + symbol->section->output_section->vma
2488                                       + symbol->section->output_offset);
2489     }
2490   return bfd_reloc_continue;
2491 }
2492
2493 static bfd_reloc_status_type
2494 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2495                          void *data, asection *input_section,
2496                          bfd *output_bfd, char **error_message)
2497 {
2498   long insn;
2499   enum elf_ppc64_reloc_type r_type;
2500   bfd_size_type octets;
2501   /* Assume 'at' branch hints.  */
2502   bfd_boolean is_isa_v2 = TRUE;
2503
2504   /* If this is a relocatable link (output_bfd test tells us), just
2505      call the generic function.  Any adjustment will be done at final
2506      link time.  */
2507   if (output_bfd != NULL)
2508     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2509                                   input_section, output_bfd, error_message);
2510
2511   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2512   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2513   insn &= ~(0x01 << 21);
2514   r_type = reloc_entry->howto->type;
2515   if (r_type == R_PPC64_ADDR14_BRTAKEN
2516       || r_type == R_PPC64_REL14_BRTAKEN)
2517     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2518
2519   if (is_isa_v2)
2520     {
2521       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2522          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2523          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2524       if ((insn & (0x14 << 21)) == (0x04 << 21))
2525         insn |= 0x02 << 21;
2526       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2527         insn |= 0x08 << 21;
2528       else
2529         goto out;
2530     }
2531   else
2532     {
2533       bfd_vma target = 0;
2534       bfd_vma from;
2535
2536       if (!bfd_is_com_section (symbol->section))
2537         target = symbol->value;
2538       target += symbol->section->output_section->vma;
2539       target += symbol->section->output_offset;
2540       target += reloc_entry->addend;
2541
2542       from = (reloc_entry->address
2543               + input_section->output_offset
2544               + input_section->output_section->vma);
2545
2546       /* Invert 'y' bit if not the default.  */
2547       if ((bfd_signed_vma) (target - from) < 0)
2548         insn ^= 0x01 << 21;
2549     }
2550   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2551  out:
2552   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2553                                  input_section, output_bfd, error_message);
2554 }
2555
2556 static bfd_reloc_status_type
2557 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2558                          void *data, asection *input_section,
2559                          bfd *output_bfd, char **error_message)
2560 {
2561   /* If this is a relocatable link (output_bfd test tells us), just
2562      call the generic function.  Any adjustment will be done at final
2563      link time.  */
2564   if (output_bfd != NULL)
2565     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2566                                   input_section, output_bfd, error_message);
2567
2568   /* Subtract the symbol section base address.  */
2569   reloc_entry->addend -= symbol->section->output_section->vma;
2570   return bfd_reloc_continue;
2571 }
2572
2573 static bfd_reloc_status_type
2574 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575                             void *data, asection *input_section,
2576                             bfd *output_bfd, char **error_message)
2577 {
2578   /* If this is a relocatable link (output_bfd test tells us), just
2579      call the generic function.  Any adjustment will be done at final
2580      link time.  */
2581   if (output_bfd != NULL)
2582     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2583                                   input_section, output_bfd, error_message);
2584
2585   /* Subtract the symbol section base address.  */
2586   reloc_entry->addend -= symbol->section->output_section->vma;
2587
2588   /* Adjust the addend for sign extension of the low 16 bits.  */
2589   reloc_entry->addend += 0x8000;
2590   return bfd_reloc_continue;
2591 }
2592
2593 static bfd_reloc_status_type
2594 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2595                      void *data, asection *input_section,
2596                      bfd *output_bfd, char **error_message)
2597 {
2598   bfd_vma TOCstart;
2599
2600   /* If this is a relocatable link (output_bfd test tells us), just
2601      call the generic function.  Any adjustment will be done at final
2602      link time.  */
2603   if (output_bfd != NULL)
2604     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2605                                   input_section, output_bfd, error_message);
2606
2607   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2608   if (TOCstart == 0)
2609     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2610
2611   /* Subtract the TOC base address.  */
2612   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2613   return bfd_reloc_continue;
2614 }
2615
2616 static bfd_reloc_status_type
2617 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2618                         void *data, asection *input_section,
2619                         bfd *output_bfd, char **error_message)
2620 {
2621   bfd_vma TOCstart;
2622
2623   /* If this is a relocatable link (output_bfd test tells us), just
2624      call the generic function.  Any adjustment will be done at final
2625      link time.  */
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2631   if (TOCstart == 0)
2632     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2633
2634   /* Subtract the TOC base address.  */
2635   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2636
2637   /* Adjust the addend for sign extension of the low 16 bits.  */
2638   reloc_entry->addend += 0x8000;
2639   return bfd_reloc_continue;
2640 }
2641
2642 static bfd_reloc_status_type
2643 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2644                        void *data, asection *input_section,
2645                        bfd *output_bfd, char **error_message)
2646 {
2647   bfd_vma TOCstart;
2648   bfd_size_type octets;
2649
2650   /* If this is a relocatable link (output_bfd test tells us), just
2651      call the generic function.  Any adjustment will be done at final
2652      link time.  */
2653   if (output_bfd != NULL)
2654     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2655                                   input_section, output_bfd, error_message);
2656
2657   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2658   if (TOCstart == 0)
2659     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2660
2661   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2662   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2663   return bfd_reloc_ok;
2664 }
2665
2666 static bfd_reloc_status_type
2667 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2668                            void *data, asection *input_section,
2669                            bfd *output_bfd, char **error_message)
2670 {
2671   /* If this is a relocatable link (output_bfd test tells us), just
2672      call the generic function.  Any adjustment will be done at final
2673      link time.  */
2674   if (output_bfd != NULL)
2675     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2676                                   input_section, output_bfd, error_message);
2677
2678   if (error_message != NULL)
2679     {
2680       static char buf[60];
2681       sprintf (buf, "generic linker can't handle %s",
2682                reloc_entry->howto->name);
2683       *error_message = buf;
2684     }
2685   return bfd_reloc_dangerous;
2686 }
2687
2688 /* Track GOT entries needed for a given symbol.  We might need more
2689    than one got entry per symbol.  */
2690 struct got_entry
2691 {
2692   struct got_entry *next;
2693
2694   /* The symbol addend that we'll be placing in the GOT.  */
2695   bfd_vma addend;
2696
2697   /* Unlike other ELF targets, we use separate GOT entries for the same
2698      symbol referenced from different input files.  This is to support
2699      automatic multiple TOC/GOT sections, where the TOC base can vary
2700      from one input file to another.  After partitioning into TOC groups
2701      we merge entries within the group.
2702
2703      Point to the BFD owning this GOT entry.  */
2704   bfd *owner;
2705
2706   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2707      TLS_TPREL or TLS_DTPREL for tls entries.  */
2708   unsigned char tls_type;
2709
2710   /* Non-zero if got.ent points to real entry.  */
2711   unsigned char is_indirect;
2712
2713   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718       struct got_entry *ent;
2719     } got;
2720 };
2721
2722 /* The same for PLT.  */
2723 struct plt_entry
2724 {
2725   struct plt_entry *next;
2726
2727   bfd_vma addend;
2728
2729   union
2730     {
2731       bfd_signed_vma refcount;
2732       bfd_vma offset;
2733     } plt;
2734 };
2735
2736 struct ppc64_elf_obj_tdata
2737 {
2738   struct elf_obj_tdata elf;
2739
2740   /* Shortcuts to dynamic linker sections.  */
2741   asection *got;
2742   asection *relgot;
2743
2744   /* Used during garbage collection.  We attach global symbols defined
2745      on removed .opd entries to this section so that the sym is removed.  */
2746   asection *deleted_section;
2747
2748   /* TLS local dynamic got entry handling.  Support for multiple GOT
2749      sections means we potentially need one of these for each input bfd.  */
2750   struct got_entry tlsld_got;
2751
2752   union {
2753     /* A copy of relocs before they are modified for --emit-relocs.  */
2754     Elf_Internal_Rela *relocs;
2755
2756     /* Section contents.  */
2757     bfd_byte *contents;
2758   } opd;
2759
2760   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2761      the reloc to be in the range -32768 to 32767.  */
2762   unsigned int has_small_toc_reloc : 1;
2763
2764   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2765      instruction not one we handle.  */
2766   unsigned int unexpected_toc_insn : 1;
2767 };
2768
2769 #define ppc64_elf_tdata(bfd) \
2770   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2771
2772 #define ppc64_tlsld_got(bfd) \
2773   (&ppc64_elf_tdata (bfd)->tlsld_got)
2774
2775 #define is_ppc64_elf(bfd) \
2776   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2777    && elf_object_id (bfd) == PPC64_ELF_DATA)
2778
2779 /* Override the generic function because we store some extras.  */
2780
2781 static bfd_boolean
2782 ppc64_elf_mkobject (bfd *abfd)
2783 {
2784   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2785                                   PPC64_ELF_DATA);
2786 }
2787
2788 /* Fix bad default arch selected for a 64 bit input bfd when the
2789    default is 32 bit.  */
2790
2791 static bfd_boolean
2792 ppc64_elf_object_p (bfd *abfd)
2793 {
2794   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2795     {
2796       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2797
2798       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2799         {
2800           /* Relies on arch after 32 bit default being 64 bit default.  */
2801           abfd->arch_info = abfd->arch_info->next;
2802           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2803         }
2804     }
2805   return TRUE;
2806 }
2807
2808 /* Support for core dump NOTE sections.  */
2809
2810 static bfd_boolean
2811 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2812 {
2813   size_t offset, size;
2814
2815   if (note->descsz != 504)
2816     return FALSE;
2817
2818   /* pr_cursig */
2819   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2820
2821   /* pr_pid */
2822   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2823
2824   /* pr_reg */
2825   offset = 112;
2826   size = 384;
2827
2828   /* Make a ".reg/999" section.  */
2829   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2830                                           size, note->descpos + offset);
2831 }
2832
2833 static bfd_boolean
2834 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2835 {
2836   if (note->descsz != 136)
2837     return FALSE;
2838
2839   elf_tdata (abfd)->core->pid
2840     = bfd_get_32 (abfd, note->descdata + 24);
2841   elf_tdata (abfd)->core->program
2842     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2843   elf_tdata (abfd)->core->command
2844     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2845
2846   return TRUE;
2847 }
2848
2849 static char *
2850 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2851                            ...)
2852 {
2853   switch (note_type)
2854     {
2855     default:
2856       return NULL;
2857
2858     case NT_PRPSINFO:
2859       {
2860         char data[136];
2861         va_list ap;
2862
2863         va_start (ap, note_type);
2864         memset (data, 0, sizeof (data));
2865         strncpy (data + 40, va_arg (ap, const char *), 16);
2866         strncpy (data + 56, va_arg (ap, const char *), 80);
2867         va_end (ap);
2868         return elfcore_write_note (abfd, buf, bufsiz,
2869                                    "CORE", note_type, data, sizeof (data));
2870       }
2871
2872     case NT_PRSTATUS:
2873       {
2874         char data[504];
2875         va_list ap;
2876         long pid;
2877         int cursig;
2878         const void *greg;
2879
2880         va_start (ap, note_type);
2881         memset (data, 0, 112);
2882         pid = va_arg (ap, long);
2883         bfd_put_32 (abfd, pid, data + 32);
2884         cursig = va_arg (ap, int);
2885         bfd_put_16 (abfd, cursig, data + 12);
2886         greg = va_arg (ap, const void *);
2887         memcpy (data + 112, greg, 384);
2888         memset (data + 496, 0, 8);
2889         va_end (ap);
2890         return elfcore_write_note (abfd, buf, bufsiz,
2891                                    "CORE", note_type, data, sizeof (data));
2892       }
2893     }
2894 }
2895
2896 /* Add extra PPC sections.  */
2897
2898 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2899 {
2900   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2901   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2902   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2903   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2906   { NULL,                     0,  0, 0,            0 }
2907 };
2908
2909 enum _ppc64_sec_type {
2910   sec_normal = 0,
2911   sec_opd = 1,
2912   sec_toc = 2
2913 };
2914
2915 struct _ppc64_elf_section_data
2916 {
2917   struct bfd_elf_section_data elf;
2918
2919   union
2920   {
2921     /* An array with one entry for each opd function descriptor.  */
2922     struct _opd_sec_data
2923     {
2924       /* Points to the function code section for local opd entries.  */
2925       asection **func_sec;
2926
2927       /* After editing .opd, adjust references to opd local syms.  */
2928       long *adjust;
2929     } opd;
2930
2931     /* An array for toc sections, indexed by offset/8.  */
2932     struct _toc_sec_data
2933     {
2934       /* Specifies the relocation symbol index used at a given toc offset.  */
2935       unsigned *symndx;
2936
2937       /* And the relocation addend.  */
2938       bfd_vma *add;
2939     } toc;
2940   } u;
2941
2942   enum _ppc64_sec_type sec_type:2;
2943
2944   /* Flag set when small branches are detected.  Used to
2945      select suitable defaults for the stub group size.  */
2946   unsigned int has_14bit_branch:1;
2947 };
2948
2949 #define ppc64_elf_section_data(sec) \
2950   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2951
2952 static bfd_boolean
2953 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2954 {
2955   if (!sec->used_by_bfd)
2956     {
2957       struct _ppc64_elf_section_data *sdata;
2958       bfd_size_type amt = sizeof (*sdata);
2959
2960       sdata = bfd_zalloc (abfd, amt);
2961       if (sdata == NULL)
2962         return FALSE;
2963       sec->used_by_bfd = sdata;
2964     }
2965
2966   return _bfd_elf_new_section_hook (abfd, sec);
2967 }
2968
2969 static struct _opd_sec_data *
2970 get_opd_info (asection * sec)
2971 {
2972   if (sec != NULL
2973       && ppc64_elf_section_data (sec) != NULL
2974       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2975     return &ppc64_elf_section_data (sec)->u.opd;
2976   return NULL;
2977 }
2978
2979 static inline int
2980 abiversion (bfd *abfd)
2981 {
2982   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2983 }
2984
2985 static inline void
2986 set_abiversion (bfd *abfd, int ver)
2987 {
2988   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2989   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2990 }
2991 \f
2992 /* Parameters for the qsort hook.  */
2993 static bfd_boolean synthetic_relocatable;
2994
2995 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2996
2997 static int
2998 compare_symbols (const void *ap, const void *bp)
2999 {
3000   const asymbol *a = * (const asymbol **) ap;
3001   const asymbol *b = * (const asymbol **) bp;
3002
3003   /* Section symbols first.  */
3004   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3005     return -1;
3006   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3007     return 1;
3008
3009   /* then .opd symbols.  */
3010   if (strcmp (a->section->name, ".opd") == 0
3011       && strcmp (b->section->name, ".opd") != 0)
3012     return -1;
3013   if (strcmp (a->section->name, ".opd") != 0
3014       && strcmp (b->section->name, ".opd") == 0)
3015     return 1;
3016
3017   /* then other code symbols.  */
3018   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3019       == (SEC_CODE | SEC_ALLOC)
3020       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3021          != (SEC_CODE | SEC_ALLOC))
3022     return -1;
3023
3024   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3025       != (SEC_CODE | SEC_ALLOC)
3026       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3027          == (SEC_CODE | SEC_ALLOC))
3028     return 1;
3029
3030   if (synthetic_relocatable)
3031     {
3032       if (a->section->id < b->section->id)
3033         return -1;
3034
3035       if (a->section->id > b->section->id)
3036         return 1;
3037     }
3038
3039   if (a->value + a->section->vma < b->value + b->section->vma)
3040     return -1;
3041
3042   if (a->value + a->section->vma > b->value + b->section->vma)
3043     return 1;
3044
3045   /* For syms with the same value, prefer strong dynamic global function
3046      syms over other syms.  */
3047   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3048     return -1;
3049
3050   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3051     return 1;
3052
3053   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3054     return -1;
3055
3056   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3057     return 1;
3058
3059   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3060     return -1;
3061
3062   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3063     return 1;
3064
3065   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3066     return -1;
3067
3068   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3069     return 1;
3070
3071   return 0;
3072 }
3073
3074 /* Search SYMS for a symbol of the given VALUE.  */
3075
3076 static asymbol *
3077 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3078 {
3079   long mid;
3080
3081   if (id == -1)
3082     {
3083       while (lo < hi)
3084         {
3085           mid = (lo + hi) >> 1;
3086           if (syms[mid]->value + syms[mid]->section->vma < value)
3087             lo = mid + 1;
3088           else if (syms[mid]->value + syms[mid]->section->vma > value)
3089             hi = mid;
3090           else
3091             return syms[mid];
3092         }
3093     }
3094   else
3095     {
3096       while (lo < hi)
3097         {
3098           mid = (lo + hi) >> 1;
3099           if (syms[mid]->section->id < id)
3100             lo = mid + 1;
3101           else if (syms[mid]->section->id > id)
3102             hi = mid;
3103           else if (syms[mid]->value < value)
3104             lo = mid + 1;
3105           else if (syms[mid]->value > value)
3106             hi = mid;
3107           else
3108             return syms[mid];
3109         }
3110     }
3111   return NULL;
3112 }
3113
3114 static bfd_boolean
3115 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3116 {
3117   bfd_vma vma = *(bfd_vma *) ptr;
3118   return ((section->flags & SEC_ALLOC) != 0
3119           && section->vma <= vma
3120           && vma < section->vma + section->size);
3121 }
3122
3123 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3124    entry syms.  Also generate @plt symbols for the glink branch table.  */
3125
3126 static long
3127 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3128                                 long static_count, asymbol **static_syms,
3129                                 long dyn_count, asymbol **dyn_syms,
3130                                 asymbol **ret)
3131 {
3132   asymbol *s;
3133   long i;
3134   long count;
3135   char *names;
3136   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3137   asection *opd = NULL;
3138   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3139   asymbol **syms;
3140   int abi = abiversion (abfd);
3141
3142   *ret = NULL;
3143
3144   if (abi < 2)
3145     {
3146       opd = bfd_get_section_by_name (abfd, ".opd");
3147       if (opd == NULL && abi == 1)
3148         return 0;
3149     }
3150
3151   symcount = static_count;
3152   if (!relocatable)
3153     symcount += dyn_count;
3154   if (symcount == 0)
3155     return 0;
3156
3157   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3158   if (syms == NULL)
3159     return -1;
3160
3161   if (!relocatable && static_count != 0 && dyn_count != 0)
3162     {
3163       /* Use both symbol tables.  */
3164       memcpy (syms, static_syms, static_count * sizeof (*syms));
3165       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3166     }
3167   else if (!relocatable && static_count == 0)
3168     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3169   else
3170     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3171
3172   synthetic_relocatable = relocatable;
3173   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3174
3175   if (!relocatable && symcount > 1)
3176     {
3177       long j;
3178       /* Trim duplicate syms, since we may have merged the normal and
3179          dynamic symbols.  Actually, we only care about syms that have
3180          different values, so trim any with the same value.  */
3181       for (i = 1, j = 1; i < symcount; ++i)
3182         if (syms[i - 1]->value + syms[i - 1]->section->vma
3183             != syms[i]->value + syms[i]->section->vma)
3184           syms[j++] = syms[i];
3185       symcount = j;
3186     }
3187
3188   i = 0;
3189   if (strcmp (syms[i]->section->name, ".opd") == 0)
3190     ++i;
3191   codesecsym = i;
3192
3193   for (; i < symcount; ++i)
3194     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195          != (SEC_CODE | SEC_ALLOC))
3196         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3197       break;
3198   codesecsymend = i;
3199
3200   for (; i < symcount; ++i)
3201     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3202       break;
3203   secsymend = i;
3204
3205   for (; i < symcount; ++i)
3206     if (strcmp (syms[i]->section->name, ".opd") != 0)
3207       break;
3208   opdsymend = i;
3209
3210   for (; i < symcount; ++i)
3211     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3212         != (SEC_CODE | SEC_ALLOC))
3213       break;
3214   symcount = i;
3215
3216   count = 0;
3217
3218   if (relocatable)
3219     {
3220       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3221       arelent *r;
3222       size_t size;
3223       long relcount;
3224
3225       if (opdsymend == secsymend)
3226         goto done;
3227
3228       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3229       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3230       if (relcount == 0)
3231         goto done;
3232
3233       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3234         {
3235           count = -1;
3236           goto done;
3237         }
3238
3239       size = 0;
3240       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3241         {
3242           asymbol *sym;
3243
3244           while (r < opd->relocation + relcount
3245                  && r->address < syms[i]->value + opd->vma)
3246             ++r;
3247
3248           if (r == opd->relocation + relcount)
3249             break;
3250
3251           if (r->address != syms[i]->value + opd->vma)
3252             continue;
3253
3254           if (r->howto->type != R_PPC64_ADDR64)
3255             continue;
3256
3257           sym = *r->sym_ptr_ptr;
3258           if (!sym_exists_at (syms, opdsymend, symcount,
3259                               sym->section->id, sym->value + r->addend))
3260             {
3261               ++count;
3262               size += sizeof (asymbol);
3263               size += strlen (syms[i]->name) + 2;
3264             }
3265         }
3266
3267       s = *ret = bfd_malloc (size);
3268       if (s == NULL)
3269         {
3270           count = -1;
3271           goto done;
3272         }
3273
3274       names = (char *) (s + count);
3275
3276       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3277         {
3278           asymbol *sym;
3279
3280           while (r < opd->relocation + relcount
3281                  && r->address < syms[i]->value + opd->vma)
3282             ++r;
3283
3284           if (r == opd->relocation + relcount)
3285             break;
3286
3287           if (r->address != syms[i]->value + opd->vma)
3288             continue;
3289
3290           if (r->howto->type != R_PPC64_ADDR64)
3291             continue;
3292
3293           sym = *r->sym_ptr_ptr;
3294           if (!sym_exists_at (syms, opdsymend, symcount,
3295                               sym->section->id, sym->value + r->addend))
3296             {
3297               size_t len;
3298
3299               *s = *syms[i];
3300               s->flags |= BSF_SYNTHETIC;
3301               s->section = sym->section;
3302               s->value = sym->value + r->addend;
3303               s->name = names;
3304               *names++ = '.';
3305               len = strlen (syms[i]->name);
3306               memcpy (names, syms[i]->name, len + 1);
3307               names += len + 1;
3308               /* Have udata.p point back to the original symbol this
3309                  synthetic symbol was derived from.  */
3310               s->udata.p = syms[i];
3311               s++;
3312             }
3313         }
3314     }
3315   else
3316     {
3317       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3318       bfd_byte *contents = NULL;
3319       size_t size;
3320       long plt_count = 0;
3321       bfd_vma glink_vma = 0, resolv_vma = 0;
3322       asection *dynamic, *glink = NULL, *relplt = NULL;
3323       arelent *p;
3324
3325       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3326         {
3327         free_contents_and_exit:
3328           if (contents)
3329             free (contents);
3330           count = -1;
3331           goto done;
3332         }
3333
3334       size = 0;
3335       for (i = secsymend; i < opdsymend; ++i)
3336         {
3337           bfd_vma ent;
3338
3339           /* Ignore bogus symbols.  */
3340           if (syms[i]->value > opd->size - 8)
3341             continue;
3342
3343           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3344           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3345             {
3346               ++count;
3347               size += sizeof (asymbol);
3348               size += strlen (syms[i]->name) + 2;
3349             }
3350         }
3351
3352       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3353       if (dyn_count != 0
3354           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3355         {
3356           bfd_byte *dynbuf, *extdyn, *extdynend;
3357           size_t extdynsize;
3358           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3359
3360           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3361             goto free_contents_and_exit;
3362
3363           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3364           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3365
3366           extdyn = dynbuf;
3367           extdynend = extdyn + dynamic->size;
3368           for (; extdyn < extdynend; extdyn += extdynsize)
3369             {
3370               Elf_Internal_Dyn dyn;
3371               (*swap_dyn_in) (abfd, extdyn, &dyn);
3372
3373               if (dyn.d_tag == DT_NULL)
3374                 break;
3375
3376               if (dyn.d_tag == DT_PPC64_GLINK)
3377                 {
3378                   /* The first glink stub starts at offset 32; see
3379                      comment in ppc64_elf_finish_dynamic_sections. */
3380                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3381                   /* The .glink section usually does not survive the final
3382                      link; search for the section (usually .text) where the
3383                      glink stubs now reside.  */
3384                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3385                                                 &glink_vma);
3386                   break;
3387                 }
3388             }
3389
3390           free (dynbuf);
3391         }
3392
3393       if (glink != NULL)
3394         {
3395           /* Determine __glink trampoline by reading the relative branch
3396              from the first glink stub.  */
3397           bfd_byte buf[4];
3398           unsigned int off = 0;
3399
3400           while (bfd_get_section_contents (abfd, glink, buf,
3401                                            glink_vma + off - glink->vma, 4))
3402             {
3403               unsigned int insn = bfd_get_32 (abfd, buf);
3404               insn ^= B_DOT;
3405               if ((insn & ~0x3fffffc) == 0)
3406                 {
3407                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3408                   break;
3409                 }
3410               off += 4;
3411               if (off > 4)
3412                 break;
3413             }
3414
3415           if (resolv_vma)
3416             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3417
3418           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3419           if (relplt != NULL)
3420             {
3421               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3422               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3423                 goto free_contents_and_exit;
3424
3425               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3426               size += plt_count * sizeof (asymbol);
3427
3428               p = relplt->relocation;
3429               for (i = 0; i < plt_count; i++, p++)
3430                 {
3431                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3432                   if (p->addend != 0)
3433                     size += sizeof ("+0x") - 1 + 16;
3434                 }
3435             }
3436         }
3437
3438       s = *ret = bfd_malloc (size);
3439       if (s == NULL)
3440         goto free_contents_and_exit;
3441
3442       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3443
3444       for (i = secsymend; i < opdsymend; ++i)
3445         {
3446           bfd_vma ent;
3447
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               long lo, hi;
3455               size_t len;
3456               asection *sec = abfd->sections;
3457
3458               *s = *syms[i];
3459               lo = codesecsym;
3460               hi = codesecsymend;
3461               while (lo < hi)
3462                 {
3463                   long mid = (lo + hi) >> 1;
3464                   if (syms[mid]->section->vma < ent)
3465                     lo = mid + 1;
3466                   else if (syms[mid]->section->vma > ent)
3467                     hi = mid;
3468                   else
3469                     {
3470                       sec = syms[mid]->section;
3471                       break;
3472                     }
3473                 }
3474
3475               if (lo >= hi && lo > codesecsym)
3476                 sec = syms[lo - 1]->section;
3477
3478               for (; sec != NULL; sec = sec->next)
3479                 {
3480                   if (sec->vma > ent)
3481                     break;
3482                   /* SEC_LOAD may not be set if SEC is from a separate debug
3483                      info file.  */
3484                   if ((sec->flags & SEC_ALLOC) == 0)
3485                     break;
3486                   if ((sec->flags & SEC_CODE) != 0)
3487                     s->section = sec;
3488                 }
3489               s->flags |= BSF_SYNTHETIC;
3490               s->value = ent - s->section->vma;
3491               s->name = names;
3492               *names++ = '.';
3493               len = strlen (syms[i]->name);
3494               memcpy (names, syms[i]->name, len + 1);
3495               names += len + 1;
3496               /* Have udata.p point back to the original symbol this
3497                  synthetic symbol was derived from.  */
3498               s->udata.p = syms[i];
3499               s++;
3500             }
3501         }
3502       free (contents);
3503
3504       if (glink != NULL && relplt != NULL)
3505         {
3506           if (resolv_vma)
3507             {
3508               /* Add a symbol for the main glink trampoline.  */
3509               memset (s, 0, sizeof *s);
3510               s->the_bfd = abfd;
3511               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3512               s->section = glink;
3513               s->value = resolv_vma - glink->vma;
3514               s->name = names;
3515               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3516               names += sizeof ("__glink_PLTresolve");
3517               s++;
3518               count++;
3519             }
3520
3521           /* FIXME: It would be very much nicer to put sym@plt on the
3522              stub rather than on the glink branch table entry.  The
3523              objdump disassembler would then use a sensible symbol
3524              name on plt calls.  The difficulty in doing so is
3525              a) finding the stubs, and,
3526              b) matching stubs against plt entries, and,
3527              c) there can be multiple stubs for a given plt entry.
3528
3529              Solving (a) could be done by code scanning, but older
3530              ppc64 binaries used different stubs to current code.
3531              (b) is the tricky one since you need to known the toc
3532              pointer for at least one function that uses a pic stub to
3533              be able to calculate the plt address referenced.
3534              (c) means gdb would need to set multiple breakpoints (or
3535              find the glink branch itself) when setting breakpoints
3536              for pending shared library loads.  */
3537           p = relplt->relocation;
3538           for (i = 0; i < plt_count; i++, p++)
3539             {
3540               size_t len;
3541
3542               *s = **p->sym_ptr_ptr;
3543               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3544                  we are defining a symbol, ensure one of them is set.  */
3545               if ((s->flags & BSF_LOCAL) == 0)
3546                 s->flags |= BSF_GLOBAL;
3547               s->flags |= BSF_SYNTHETIC;
3548               s->section = glink;
3549               s->value = glink_vma - glink->vma;
3550               s->name = names;
3551               s->udata.p = NULL;
3552               len = strlen ((*p->sym_ptr_ptr)->name);
3553               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3554               names += len;
3555               if (p->addend != 0)
3556                 {
3557                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3558                   names += sizeof ("+0x") - 1;
3559                   bfd_sprintf_vma (abfd, names, p->addend);
3560                   names += strlen (names);
3561                 }
3562               memcpy (names, "@plt", sizeof ("@plt"));
3563               names += sizeof ("@plt");
3564               s++;
3565               if (abi < 2)
3566                 {
3567                   glink_vma += 8;
3568                   if (i >= 0x8000)
3569                     glink_vma += 4;
3570                 }
3571               else
3572                 glink_vma += 4;
3573             }
3574           count += plt_count;
3575         }
3576     }
3577
3578  done:
3579   free (syms);
3580   return count;
3581 }
3582 \f
3583 /* The following functions are specific to the ELF linker, while
3584    functions above are used generally.  Those named ppc64_elf_* are
3585    called by the main ELF linker code.  They appear in this file more
3586    or less in the order in which they are called.  eg.
3587    ppc64_elf_check_relocs is called early in the link process,
3588    ppc64_elf_finish_dynamic_sections is one of the last functions
3589    called.
3590
3591    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3592    functions have both a function code symbol and a function descriptor
3593    symbol.  A call to foo in a relocatable object file looks like:
3594
3595    .            .text
3596    .    x:
3597    .            bl      .foo
3598    .            nop
3599
3600    The function definition in another object file might be:
3601
3602    .            .section .opd
3603    .    foo:    .quad   .foo
3604    .            .quad   .TOC.@tocbase
3605    .            .quad   0
3606    .
3607    .            .text
3608    .    .foo:   blr
3609
3610    When the linker resolves the call during a static link, the branch
3611    unsurprisingly just goes to .foo and the .opd information is unused.
3612    If the function definition is in a shared library, things are a little
3613    different:  The call goes via a plt call stub, the opd information gets
3614    copied to the plt, and the linker patches the nop.
3615
3616    .    x:
3617    .            bl      .foo_stub
3618    .            ld      2,40(1)
3619    .
3620    .
3621    .    .foo_stub:
3622    .            std     2,40(1)                 # in practice, the call stub
3623    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3624    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3625    .            ld      12,0(11)
3626    .            ld      2,8(11)
3627    .            mtctr   12
3628    .            ld      11,16(11)
3629    .            bctr
3630    .
3631    .            .section .plt
3632    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3633
3634    The "reloc ()" notation is supposed to indicate that the linker emits
3635    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3636    copying.
3637
3638    What are the difficulties here?  Well, firstly, the relocations
3639    examined by the linker in check_relocs are against the function code
3640    sym .foo, while the dynamic relocation in the plt is emitted against
3641    the function descriptor symbol, foo.  Somewhere along the line, we need
3642    to carefully copy dynamic link information from one symbol to the other.
3643    Secondly, the generic part of the elf linker will make .foo a dynamic
3644    symbol as is normal for most other backends.  We need foo dynamic
3645    instead, at least for an application final link.  However, when
3646    creating a shared library containing foo, we need to have both symbols
3647    dynamic so that references to .foo are satisfied during the early
3648    stages of linking.  Otherwise the linker might decide to pull in a
3649    definition from some other object, eg. a static library.
3650
3651    Update: As of August 2004, we support a new convention.  Function
3652    calls may use the function descriptor symbol, ie. "bl foo".  This
3653    behaves exactly as "bl .foo".  */
3654
3655 /* Of those relocs that might be copied as dynamic relocs, this function
3656    selects those that must be copied when linking a shared library,
3657    even when the symbol is local.  */
3658
3659 static int
3660 must_be_dyn_reloc (struct bfd_link_info *info,
3661                    enum elf_ppc64_reloc_type r_type)
3662 {
3663   switch (r_type)
3664     {
3665     default:
3666       return 1;
3667
3668     case R_PPC64_REL32:
3669     case R_PPC64_REL64:
3670     case R_PPC64_REL30:
3671       return 0;
3672
3673     case R_PPC64_TPREL16:
3674     case R_PPC64_TPREL16_LO:
3675     case R_PPC64_TPREL16_HI:
3676     case R_PPC64_TPREL16_HA:
3677     case R_PPC64_TPREL16_DS:
3678     case R_PPC64_TPREL16_LO_DS:
3679     case R_PPC64_TPREL16_HIGH:
3680     case R_PPC64_TPREL16_HIGHA:
3681     case R_PPC64_TPREL16_HIGHER:
3682     case R_PPC64_TPREL16_HIGHERA:
3683     case R_PPC64_TPREL16_HIGHEST:
3684     case R_PPC64_TPREL16_HIGHESTA:
3685     case R_PPC64_TPREL64:
3686       return !info->executable;
3687     }
3688 }
3689
3690 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3691    copying dynamic variables from a shared lib into an app's dynbss
3692    section, and instead use a dynamic relocation to point into the
3693    shared lib.  With code that gcc generates, it's vital that this be
3694    enabled;  In the PowerPC64 ABI, the address of a function is actually
3695    the address of a function descriptor, which resides in the .opd
3696    section.  gcc uses the descriptor directly rather than going via the
3697    GOT as some other ABI's do, which means that initialized function
3698    pointers must reference the descriptor.  Thus, a function pointer
3699    initialized to the address of a function in a shared library will
3700    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3701    redefines the function descriptor symbol to point to the copy.  This
3702    presents a problem as a plt entry for that function is also
3703    initialized from the function descriptor symbol and the copy reloc
3704    may not be initialized first.  */
3705 #define ELIMINATE_COPY_RELOCS 1
3706
3707 /* Section name for stubs is the associated section name plus this
3708    string.  */
3709 #define STUB_SUFFIX ".stub"
3710
3711 /* Linker stubs.
3712    ppc_stub_long_branch:
3713    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3714    destination, but a 24 bit branch in a stub section will reach.
3715    .    b       dest
3716
3717    ppc_stub_plt_branch:
3718    Similar to the above, but a 24 bit branch in the stub section won't
3719    reach its destination.
3720    .    addis   %r11,%r2,xxx@toc@ha
3721    .    ld      %r12,xxx@toc@l(%r11)
3722    .    mtctr   %r12
3723    .    bctr
3724
3725    ppc_stub_plt_call:
3726    Used to call a function in a shared library.  If it so happens that
3727    the plt entry referenced crosses a 64k boundary, then an extra
3728    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3729    .    std     %r2,40(%r1)
3730    .    addis   %r11,%r2,xxx@toc@ha
3731    .    ld      %r12,xxx+0@toc@l(%r11)
3732    .    mtctr   %r12
3733    .    ld      %r2,xxx+8@toc@l(%r11)
3734    .    ld      %r11,xxx+16@toc@l(%r11)
3735    .    bctr
3736
3737    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3738    code to adjust the value and save r2 to support multiple toc sections.
3739    A ppc_stub_long_branch with an r2 offset looks like:
3740    .    std     %r2,40(%r1)
3741    .    addis   %r2,%r2,off@ha
3742    .    addi    %r2,%r2,off@l
3743    .    b       dest
3744
3745    A ppc_stub_plt_branch with an r2 offset looks like:
3746    .    std     %r2,40(%r1)
3747    .    addis   %r11,%r2,xxx@toc@ha
3748    .    ld      %r12,xxx@toc@l(%r11)
3749    .    addis   %r2,%r2,off@ha
3750    .    addi    %r2,%r2,off@l
3751    .    mtctr   %r12
3752    .    bctr
3753
3754    In cases where the "addis" instruction would add zero, the "addis" is
3755    omitted and following instructions modified slightly in some cases.
3756 */
3757
3758 enum ppc_stub_type {
3759   ppc_stub_none,
3760   ppc_stub_long_branch,
3761   ppc_stub_long_branch_r2off,
3762   ppc_stub_plt_branch,
3763   ppc_stub_plt_branch_r2off,
3764   ppc_stub_plt_call,
3765   ppc_stub_plt_call_r2save
3766 };
3767
3768 struct ppc_stub_hash_entry {
3769
3770   /* Base hash table entry structure.  */
3771   struct bfd_hash_entry root;
3772
3773   enum ppc_stub_type stub_type;
3774
3775   /* The stub section.  */
3776   asection *stub_sec;
3777
3778   /* Offset within stub_sec of the beginning of this stub.  */
3779   bfd_vma stub_offset;
3780
3781   /* Given the symbol's value and its section we can determine its final
3782      value when building the stubs (so the stub knows where to jump.  */
3783   bfd_vma target_value;
3784   asection *target_section;
3785
3786   /* The symbol table entry, if any, that this was derived from.  */
3787   struct ppc_link_hash_entry *h;
3788   struct plt_entry *plt_ent;
3789
3790   /* Where this stub is being called from, or, in the case of combined
3791      stub sections, the first input section in the group.  */
3792   asection *id_sec;
3793
3794   /* Symbol st_other.  */
3795   unsigned char other;
3796 };
3797
3798 struct ppc_branch_hash_entry {
3799
3800   /* Base hash table entry structure.  */
3801   struct bfd_hash_entry root;
3802
3803   /* Offset within branch lookup table.  */
3804   unsigned int offset;
3805
3806   /* Generation marker.  */
3807   unsigned int iter;
3808 };
3809
3810 /* Used to track dynamic relocations for local symbols.  */
3811 struct ppc_dyn_relocs
3812 {
3813   struct ppc_dyn_relocs *next;
3814
3815   /* The input section of the reloc.  */
3816   asection *sec;
3817
3818   /* Total number of relocs copied for the input section.  */
3819   unsigned int count : 31;
3820
3821   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3822   unsigned int ifunc : 1;
3823 };
3824
3825 struct ppc_link_hash_entry
3826 {
3827   struct elf_link_hash_entry elf;
3828
3829   union {
3830     /* A pointer to the most recently used stub hash entry against this
3831        symbol.  */
3832     struct ppc_stub_hash_entry *stub_cache;
3833
3834     /* A pointer to the next symbol starting with a '.'  */
3835     struct ppc_link_hash_entry *next_dot_sym;
3836   } u;
3837
3838   /* Track dynamic relocs copied for this symbol.  */
3839   struct elf_dyn_relocs *dyn_relocs;
3840
3841   /* Link between function code and descriptor symbols.  */
3842   struct ppc_link_hash_entry *oh;
3843
3844   /* Flag function code and descriptor symbols.  */
3845   unsigned int is_func:1;
3846   unsigned int is_func_descriptor:1;
3847   unsigned int fake:1;
3848
3849   /* Whether global opd/toc sym has been adjusted or not.
3850      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3851      should be set for all globals defined in any opd/toc section.  */
3852   unsigned int adjust_done:1;
3853
3854   /* Set if we twiddled this symbol to weak at some stage.  */
3855   unsigned int was_undefined:1;
3856
3857   /* Contexts in which symbol is used in the GOT (or TOC).
3858      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3859      corresponding relocs are encountered during check_relocs.
3860      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3861      indicate the corresponding GOT entry type is not needed.
3862      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3863      a TPREL one.  We use a separate flag rather than setting TPREL
3864      just for convenience in distinguishing the two cases.  */
3865 #define TLS_GD           1      /* GD reloc. */
3866 #define TLS_LD           2      /* LD reloc. */
3867 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3868 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3869 #define TLS_TLS         16      /* Any TLS reloc.  */
3870 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3871 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3872 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3873   unsigned char tls_mask;
3874 };
3875
3876 /* ppc64 ELF linker hash table.  */
3877
3878 struct ppc_link_hash_table
3879 {
3880   struct elf_link_hash_table elf;
3881
3882   /* The stub hash table.  */
3883   struct bfd_hash_table stub_hash_table;
3884
3885   /* Another hash table for plt_branch stubs.  */
3886   struct bfd_hash_table branch_hash_table;
3887
3888   /* Hash table for function prologue tocsave.  */
3889   htab_t tocsave_htab;
3890
3891   /* Various options and other info passed from the linker.  */
3892   struct ppc64_elf_params *params;
3893
3894   /* Array to keep track of which stub sections have been created, and
3895      information on stub grouping.  */
3896   struct map_stub {
3897     /* This is the section to which stubs in the group will be attached.  */
3898     asection *link_sec;
3899     /* The stub section.  */
3900     asection *stub_sec;
3901     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3902     bfd_vma toc_off;
3903   } *stub_group;
3904
3905   /* Temp used when calculating TOC pointers.  */
3906   bfd_vma toc_curr;
3907   bfd *toc_bfd;
3908   asection *toc_first_sec;
3909
3910   /* Highest input section id.  */
3911   int top_id;
3912
3913   /* Highest output section index.  */
3914   int top_index;
3915
3916   /* Used when adding symbols.  */
3917   struct ppc_link_hash_entry *dot_syms;
3918
3919   /* List of input sections for each output section.  */
3920   asection **input_list;
3921
3922   /* Shortcuts to get to dynamic linker sections.  */
3923   asection *dynbss;
3924   asection *relbss;
3925   asection *glink;
3926   asection *sfpr;
3927   asection *brlt;
3928   asection *relbrlt;
3929   asection *glink_eh_frame;
3930
3931   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3932   struct ppc_link_hash_entry *tls_get_addr;
3933   struct ppc_link_hash_entry *tls_get_addr_fd;
3934
3935   /* The size of reliplt used by got entry relocs.  */
3936   bfd_size_type got_reli_size;
3937
3938   /* Statistics.  */
3939   unsigned long stub_count[ppc_stub_plt_call_r2save];
3940
3941   /* Number of stubs against global syms.  */
3942   unsigned long stub_globals;
3943
3944   /* Set if we're linking code with function descriptors.  */
3945   unsigned int opd_abi:1;
3946
3947   /* Support for multiple toc sections.  */
3948   unsigned int do_multi_toc:1;
3949   unsigned int multi_toc_needed:1;
3950   unsigned int second_toc_pass:1;
3951   unsigned int do_toc_opt:1;
3952
3953   /* Set on error.  */
3954   unsigned int stub_error:1;
3955
3956   /* Temp used by ppc64_elf_process_dot_syms.  */
3957   unsigned int twiddled_syms:1;
3958
3959   /* Incremented every time we size stubs.  */
3960   unsigned int stub_iteration;
3961
3962   /* Small local sym cache.  */
3963   struct sym_cache sym_cache;
3964 };
3965
3966 /* Rename some of the generic section flags to better document how they
3967    are used here.  */
3968
3969 /* Nonzero if this section has TLS related relocations.  */
3970 #define has_tls_reloc sec_flg0
3971
3972 /* Nonzero if this section has a call to __tls_get_addr.  */
3973 #define has_tls_get_addr_call sec_flg1
3974
3975 /* Nonzero if this section has any toc or got relocs.  */
3976 #define has_toc_reloc sec_flg2
3977
3978 /* Nonzero if this section has a call to another section that uses
3979    the toc or got.  */
3980 #define makes_toc_func_call sec_flg3
3981
3982 /* Recursion protection when determining above flag.  */
3983 #define call_check_in_progress sec_flg4
3984 #define call_check_done sec_flg5
3985
3986 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3987
3988 #define ppc_hash_table(p) \
3989   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3990   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3991
3992 #define ppc_stub_hash_lookup(table, string, create, copy) \
3993   ((struct ppc_stub_hash_entry *) \
3994    bfd_hash_lookup ((table), (string), (create), (copy)))
3995
3996 #define ppc_branch_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_branch_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 /* Create an entry in the stub hash table.  */
4001
4002 static struct bfd_hash_entry *
4003 stub_hash_newfunc (struct bfd_hash_entry *entry,
4004                    struct bfd_hash_table *table,
4005                    const char *string)
4006 {
4007   /* Allocate the structure if it has not already been allocated by a
4008      subclass.  */
4009   if (entry == NULL)
4010     {
4011       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4012       if (entry == NULL)
4013         return entry;
4014     }
4015
4016   /* Call the allocation method of the superclass.  */
4017   entry = bfd_hash_newfunc (entry, table, string);
4018   if (entry != NULL)
4019     {
4020       struct ppc_stub_hash_entry *eh;
4021
4022       /* Initialize the local fields.  */
4023       eh = (struct ppc_stub_hash_entry *) entry;
4024       eh->stub_type = ppc_stub_none;
4025       eh->stub_sec = NULL;
4026       eh->stub_offset = 0;
4027       eh->target_value = 0;
4028       eh->target_section = NULL;
4029       eh->h = NULL;
4030       eh->plt_ent = NULL;
4031       eh->id_sec = NULL;
4032       eh->other = 0;
4033     }
4034
4035   return entry;
4036 }
4037
4038 /* Create an entry in the branch hash table.  */
4039
4040 static struct bfd_hash_entry *
4041 branch_hash_newfunc (struct bfd_hash_entry *entry,
4042                      struct bfd_hash_table *table,
4043                      const char *string)
4044 {
4045   /* Allocate the structure if it has not already been allocated by a
4046      subclass.  */
4047   if (entry == NULL)
4048     {
4049       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4050       if (entry == NULL)
4051         return entry;
4052     }
4053
4054   /* Call the allocation method of the superclass.  */
4055   entry = bfd_hash_newfunc (entry, table, string);
4056   if (entry != NULL)
4057     {
4058       struct ppc_branch_hash_entry *eh;
4059
4060       /* Initialize the local fields.  */
4061       eh = (struct ppc_branch_hash_entry *) entry;
4062       eh->offset = 0;
4063       eh->iter = 0;
4064     }
4065
4066   return entry;
4067 }
4068
4069 /* Create an entry in a ppc64 ELF linker hash table.  */
4070
4071 static struct bfd_hash_entry *
4072 link_hash_newfunc (struct bfd_hash_entry *entry,
4073                    struct bfd_hash_table *table,
4074                    const char *string)
4075 {
4076   /* Allocate the structure if it has not already been allocated by a
4077      subclass.  */
4078   if (entry == NULL)
4079     {
4080       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4081       if (entry == NULL)
4082         return entry;
4083     }
4084
4085   /* Call the allocation method of the superclass.  */
4086   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4087   if (entry != NULL)
4088     {
4089       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4090
4091       memset (&eh->u.stub_cache, 0,
4092               (sizeof (struct ppc_link_hash_entry)
4093                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4094
4095       /* When making function calls, old ABI code references function entry
4096          points (dot symbols), while new ABI code references the function
4097          descriptor symbol.  We need to make any combination of reference and
4098          definition work together, without breaking archive linking.
4099
4100          For a defined function "foo" and an undefined call to "bar":
4101          An old object defines "foo" and ".foo", references ".bar" (possibly
4102          "bar" too).
4103          A new object defines "foo" and references "bar".
4104
4105          A new object thus has no problem with its undefined symbols being
4106          satisfied by definitions in an old object.  On the other hand, the
4107          old object won't have ".bar" satisfied by a new object.
4108
4109          Keep a list of newly added dot-symbols.  */
4110
4111       if (string[0] == '.')
4112         {
4113           struct ppc_link_hash_table *htab;
4114
4115           htab = (struct ppc_link_hash_table *) table;
4116           eh->u.next_dot_sym = htab->dot_syms;
4117           htab->dot_syms = eh;
4118         }
4119     }
4120
4121   return entry;
4122 }
4123
4124 struct tocsave_entry {
4125   asection *sec;
4126   bfd_vma offset;
4127 };
4128
4129 static hashval_t
4130 tocsave_htab_hash (const void *p)
4131 {
4132   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4133   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4134 }
4135
4136 static int
4137 tocsave_htab_eq (const void *p1, const void *p2)
4138 {
4139   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4140   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4141   return e1->sec == e2->sec && e1->offset == e2->offset;
4142 }
4143
4144 /* Create a ppc64 ELF linker hash table.  */
4145
4146 static struct bfd_link_hash_table *
4147 ppc64_elf_link_hash_table_create (bfd *abfd)
4148 {
4149   struct ppc_link_hash_table *htab;
4150   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4151
4152   htab = bfd_zmalloc (amt);
4153   if (htab == NULL)
4154     return NULL;
4155
4156   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4157                                       sizeof (struct ppc_link_hash_entry),
4158                                       PPC64_ELF_DATA))
4159     {
4160       free (htab);
4161       return NULL;
4162     }
4163
4164   /* Init the stub hash table too.  */
4165   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4166                             sizeof (struct ppc_stub_hash_entry)))
4167     {
4168       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4169       return NULL;
4170     }
4171
4172   /* And the branch hash table.  */
4173   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4174                             sizeof (struct ppc_branch_hash_entry)))
4175     {
4176       bfd_hash_table_free (&htab->stub_hash_table);
4177       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4178       return NULL;
4179     }
4180
4181   htab->tocsave_htab = htab_try_create (1024,
4182                                         tocsave_htab_hash,
4183                                         tocsave_htab_eq,
4184                                         NULL);
4185   if (htab->tocsave_htab == NULL)
4186     {
4187       bfd_hash_table_free (&htab->branch_hash_table);
4188       bfd_hash_table_free (&htab->stub_hash_table);
4189       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4190       return NULL;
4191     }
4192
4193   /* Initializing two fields of the union is just cosmetic.  We really
4194      only care about glist, but when compiled on a 32-bit host the
4195      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4196      debugger inspection of these fields look nicer.  */
4197   htab->elf.init_got_refcount.refcount = 0;
4198   htab->elf.init_got_refcount.glist = NULL;
4199   htab->elf.init_plt_refcount.refcount = 0;
4200   htab->elf.init_plt_refcount.glist = NULL;
4201   htab->elf.init_got_offset.offset = 0;
4202   htab->elf.init_got_offset.glist = NULL;
4203   htab->elf.init_plt_offset.offset = 0;
4204   htab->elf.init_plt_offset.glist = NULL;
4205
4206   return &htab->elf.root;
4207 }
4208
4209 /* Free the derived linker hash table.  */
4210
4211 static void
4212 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4213 {
4214   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4215
4216   bfd_hash_table_free (&htab->stub_hash_table);
4217   bfd_hash_table_free (&htab->branch_hash_table);
4218   if (htab->tocsave_htab)
4219     htab_delete (htab->tocsave_htab);
4220   _bfd_elf_link_hash_table_free (hash);
4221 }
4222
4223 /* Create sections for linker generated code.  */
4224
4225 static bfd_boolean
4226 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4227 {
4228   struct ppc_link_hash_table *htab;
4229   flagword flags;
4230
4231   htab = ppc_hash_table (info);
4232
4233   /* Create .sfpr for code to save and restore fp regs.  */
4234   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4235            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4236   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4237                                                    flags);
4238   if (htab->sfpr == NULL
4239       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4240     return FALSE;
4241
4242   /* Create .glink for lazy dynamic linking support.  */
4243   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4244                                                     flags);
4245   if (htab->glink == NULL
4246       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4247     return FALSE;
4248
4249   if (!info->no_ld_generated_unwind_info)
4250     {
4251       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4252                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4253       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4254                                                                  ".eh_frame",
4255                                                                  flags);
4256       if (htab->glink_eh_frame == NULL
4257           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4258         return FALSE;
4259     }
4260
4261   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4262   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4263   if (htab->elf.iplt == NULL
4264       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4265     return FALSE;
4266
4267   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4268            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4269   htab->elf.irelplt
4270     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4271   if (htab->elf.irelplt == NULL
4272       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4273     return FALSE;
4274
4275   /* Create branch lookup table for plt_branch stubs.  */
4276   flags = (SEC_ALLOC | SEC_LOAD
4277            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4278   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4279                                                    flags);
4280   if (htab->brlt == NULL
4281       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4282     return FALSE;
4283
4284   if (!info->shared)
4285     return TRUE;
4286
4287   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4288            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4289   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4290                                                       ".rela.branch_lt",
4291                                                       flags);
4292   if (htab->relbrlt == NULL
4293       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4294     return FALSE;
4295
4296   return TRUE;
4297 }
4298
4299 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4300
4301 bfd_boolean
4302 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4303                          struct ppc64_elf_params *params)
4304 {
4305   struct ppc_link_hash_table *htab;
4306
4307   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4308
4309 /* Always hook our dynamic sections into the first bfd, which is the
4310    linker created stub bfd.  This ensures that the GOT header is at
4311    the start of the output TOC section.  */
4312   htab = ppc_hash_table (info);
4313   if (htab == NULL)
4314     return FALSE;
4315   htab->elf.dynobj = params->stub_bfd;
4316   htab->params = params;
4317
4318   if (info->relocatable)
4319     return TRUE;
4320
4321   return create_linkage_sections (htab->elf.dynobj, info);
4322 }
4323
4324 /* Build a name for an entry in the stub hash table.  */
4325
4326 static char *
4327 ppc_stub_name (const asection *input_section,
4328                const asection *sym_sec,
4329                const struct ppc_link_hash_entry *h,
4330                const Elf_Internal_Rela *rel)
4331 {
4332   char *stub_name;
4333   ssize_t len;
4334
4335   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4336      offsets from a sym as a branch target?  In fact, we could
4337      probably assume the addend is always zero.  */
4338   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4339
4340   if (h)
4341     {
4342       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4343       stub_name = bfd_malloc (len);
4344       if (stub_name == NULL)
4345         return stub_name;
4346
4347       len = sprintf (stub_name, "%08x.%s+%x",
4348                      input_section->id & 0xffffffff,
4349                      h->elf.root.root.string,
4350                      (int) rel->r_addend & 0xffffffff);
4351     }
4352   else
4353     {
4354       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4355       stub_name = bfd_malloc (len);
4356       if (stub_name == NULL)
4357         return stub_name;
4358
4359       len = sprintf (stub_name, "%08x.%x:%x+%x",
4360                      input_section->id & 0xffffffff,
4361                      sym_sec->id & 0xffffffff,
4362                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4363                      (int) rel->r_addend & 0xffffffff);
4364     }
4365   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4366     stub_name[len - 2] = 0;
4367   return stub_name;
4368 }
4369
4370 /* Look up an entry in the stub hash.  Stub entries are cached because
4371    creating the stub name takes a bit of time.  */
4372
4373 static struct ppc_stub_hash_entry *
4374 ppc_get_stub_entry (const asection *input_section,
4375                     const asection *sym_sec,
4376                     struct ppc_link_hash_entry *h,
4377                     const Elf_Internal_Rela *rel,
4378                     struct ppc_link_hash_table *htab)
4379 {
4380   struct ppc_stub_hash_entry *stub_entry;
4381   const asection *id_sec;
4382
4383   /* If this input section is part of a group of sections sharing one
4384      stub section, then use the id of the first section in the group.
4385      Stub names need to include a section id, as there may well be
4386      more than one stub used to reach say, printf, and we need to
4387      distinguish between them.  */
4388   id_sec = htab->stub_group[input_section->id].link_sec;
4389
4390   if (h != NULL && h->u.stub_cache != NULL
4391       && h->u.stub_cache->h == h
4392       && h->u.stub_cache->id_sec == id_sec)
4393     {
4394       stub_entry = h->u.stub_cache;
4395     }
4396   else
4397     {
4398       char *stub_name;
4399
4400       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4401       if (stub_name == NULL)
4402         return NULL;
4403
4404       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4405                                          stub_name, FALSE, FALSE);
4406       if (h != NULL)
4407         h->u.stub_cache = stub_entry;
4408
4409       free (stub_name);
4410     }
4411
4412   return stub_entry;
4413 }
4414
4415 /* Add a new stub entry to the stub hash.  Not all fields of the new
4416    stub entry are initialised.  */
4417
4418 static struct ppc_stub_hash_entry *
4419 ppc_add_stub (const char *stub_name,
4420               asection *section,
4421               struct bfd_link_info *info)
4422 {
4423   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4424   asection *link_sec;
4425   asection *stub_sec;
4426   struct ppc_stub_hash_entry *stub_entry;
4427
4428   link_sec = htab->stub_group[section->id].link_sec;
4429   stub_sec = htab->stub_group[section->id].stub_sec;
4430   if (stub_sec == NULL)
4431     {
4432       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4433       if (stub_sec == NULL)
4434         {
4435           size_t namelen;
4436           bfd_size_type len;
4437           char *s_name;
4438
4439           namelen = strlen (link_sec->name);
4440           len = namelen + sizeof (STUB_SUFFIX);
4441           s_name = bfd_alloc (htab->params->stub_bfd, len);
4442           if (s_name == NULL)
4443             return NULL;
4444
4445           memcpy (s_name, link_sec->name, namelen);
4446           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4447           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4448           if (stub_sec == NULL)
4449             return NULL;
4450           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4451         }
4452       htab->stub_group[section->id].stub_sec = stub_sec;
4453     }
4454
4455   /* Enter this entry into the linker stub hash table.  */
4456   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4457                                      TRUE, FALSE);
4458   if (stub_entry == NULL)
4459     {
4460       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4461                               section->owner, stub_name);
4462       return NULL;
4463     }
4464
4465   stub_entry->stub_sec = stub_sec;
4466   stub_entry->stub_offset = 0;
4467   stub_entry->id_sec = link_sec;
4468   return stub_entry;
4469 }
4470
4471 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4472    not already done.  */
4473
4474 static bfd_boolean
4475 create_got_section (bfd *abfd, struct bfd_link_info *info)
4476 {
4477   asection *got, *relgot;
4478   flagword flags;
4479   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4480
4481   if (!is_ppc64_elf (abfd))
4482     return FALSE;
4483   if (htab == NULL)
4484     return FALSE;
4485
4486   if (!htab->elf.sgot
4487       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4488     return FALSE;
4489
4490   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4491            | SEC_LINKER_CREATED);
4492
4493   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4494   if (!got
4495       || !bfd_set_section_alignment (abfd, got, 3))
4496     return FALSE;
4497
4498   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4499                                                flags | SEC_READONLY);
4500   if (!relgot
4501       || ! bfd_set_section_alignment (abfd, relgot, 3))
4502     return FALSE;
4503
4504   ppc64_elf_tdata (abfd)->got = got;
4505   ppc64_elf_tdata (abfd)->relgot = relgot;
4506   return TRUE;
4507 }
4508
4509 /* Create the dynamic sections, and set up shortcuts.  */
4510
4511 static bfd_boolean
4512 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4513 {
4514   struct ppc_link_hash_table *htab;
4515
4516   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4517     return FALSE;
4518
4519   htab = ppc_hash_table (info);
4520   if (htab == NULL)
4521     return FALSE;
4522
4523   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4524   if (!info->shared)
4525     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4526
4527   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4528       || (!info->shared && !htab->relbss))
4529     abort ();
4530
4531   return TRUE;
4532 }
4533
4534 /* Follow indirect and warning symbol links.  */
4535
4536 static inline struct bfd_link_hash_entry *
4537 follow_link (struct bfd_link_hash_entry *h)
4538 {
4539   while (h->type == bfd_link_hash_indirect
4540          || h->type == bfd_link_hash_warning)
4541     h = h->u.i.link;
4542   return h;
4543 }
4544
4545 static inline struct elf_link_hash_entry *
4546 elf_follow_link (struct elf_link_hash_entry *h)
4547 {
4548   return (struct elf_link_hash_entry *) follow_link (&h->root);
4549 }
4550
4551 static inline struct ppc_link_hash_entry *
4552 ppc_follow_link (struct ppc_link_hash_entry *h)
4553 {
4554   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4555 }
4556
4557 /* Merge PLT info on FROM with that on TO.  */
4558
4559 static void
4560 move_plt_plist (struct ppc_link_hash_entry *from,
4561                 struct ppc_link_hash_entry *to)
4562 {
4563   if (from->elf.plt.plist != NULL)
4564     {
4565       if (to->elf.plt.plist != NULL)
4566         {
4567           struct plt_entry **entp;
4568           struct plt_entry *ent;
4569
4570           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4571             {
4572               struct plt_entry *dent;
4573
4574               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4575                 if (dent->addend == ent->addend)
4576                   {
4577                     dent->plt.refcount += ent->plt.refcount;
4578                     *entp = ent->next;
4579                     break;
4580                   }
4581               if (dent == NULL)
4582                 entp = &ent->next;
4583             }
4584           *entp = to->elf.plt.plist;
4585         }
4586
4587       to->elf.plt.plist = from->elf.plt.plist;
4588       from->elf.plt.plist = NULL;
4589     }
4590 }
4591
4592 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4593
4594 static void
4595 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4596                                 struct elf_link_hash_entry *dir,
4597                                 struct elf_link_hash_entry *ind)
4598 {
4599   struct ppc_link_hash_entry *edir, *eind;
4600
4601   edir = (struct ppc_link_hash_entry *) dir;
4602   eind = (struct ppc_link_hash_entry *) ind;
4603
4604   edir->is_func |= eind->is_func;
4605   edir->is_func_descriptor |= eind->is_func_descriptor;
4606   edir->tls_mask |= eind->tls_mask;
4607   if (eind->oh != NULL)
4608     edir->oh = ppc_follow_link (eind->oh);
4609
4610   /* If called to transfer flags for a weakdef during processing
4611      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4612      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4613   if (!(ELIMINATE_COPY_RELOCS
4614         && eind->elf.root.type != bfd_link_hash_indirect
4615         && edir->elf.dynamic_adjusted))
4616     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4617
4618   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4619   edir->elf.ref_regular |= eind->elf.ref_regular;
4620   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4621   edir->elf.needs_plt |= eind->elf.needs_plt;
4622   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4623
4624   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4625   if (eind->dyn_relocs != NULL)
4626     {
4627       if (edir->dyn_relocs != NULL)
4628         {
4629           struct elf_dyn_relocs **pp;
4630           struct elf_dyn_relocs *p;
4631
4632           /* Add reloc counts against the indirect sym to the direct sym
4633              list.  Merge any entries against the same section.  */
4634           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4635             {
4636               struct elf_dyn_relocs *q;
4637
4638               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4639                 if (q->sec == p->sec)
4640                   {
4641                     q->pc_count += p->pc_count;
4642                     q->count += p->count;
4643                     *pp = p->next;
4644                     break;
4645                   }
4646               if (q == NULL)
4647                 pp = &p->next;
4648             }
4649           *pp = edir->dyn_relocs;
4650         }
4651
4652       edir->dyn_relocs = eind->dyn_relocs;
4653       eind->dyn_relocs = NULL;
4654     }
4655
4656   /* If we were called to copy over info for a weak sym, that's all.
4657      You might think dyn_relocs need not be copied over;  After all,
4658      both syms will be dynamic or both non-dynamic so we're just
4659      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4660      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4661      dyn_relocs in read-only sections, and it does so on what is the
4662      DIR sym here.  */
4663   if (eind->elf.root.type != bfd_link_hash_indirect)
4664     return;
4665
4666   /* Copy over got entries that we may have already seen to the
4667      symbol which just became indirect.  */
4668   if (eind->elf.got.glist != NULL)
4669     {
4670       if (edir->elf.got.glist != NULL)
4671         {
4672           struct got_entry **entp;
4673           struct got_entry *ent;
4674
4675           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4676             {
4677               struct got_entry *dent;
4678
4679               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4680                 if (dent->addend == ent->addend
4681                     && dent->owner == ent->owner
4682                     && dent->tls_type == ent->tls_type)
4683                   {
4684                     dent->got.refcount += ent->got.refcount;
4685                     *entp = ent->next;
4686                     break;
4687                   }
4688               if (dent == NULL)
4689                 entp = &ent->next;
4690             }
4691           *entp = edir->elf.got.glist;
4692         }
4693
4694       edir->elf.got.glist = eind->elf.got.glist;
4695       eind->elf.got.glist = NULL;
4696     }
4697
4698   /* And plt entries.  */
4699   move_plt_plist (eind, edir);
4700
4701   if (eind->elf.dynindx != -1)
4702     {
4703       if (edir->elf.dynindx != -1)
4704         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4705                                 edir->elf.dynstr_index);
4706       edir->elf.dynindx = eind->elf.dynindx;
4707       edir->elf.dynstr_index = eind->elf.dynstr_index;
4708       eind->elf.dynindx = -1;
4709       eind->elf.dynstr_index = 0;
4710     }
4711 }
4712
4713 /* Find the function descriptor hash entry from the given function code
4714    hash entry FH.  Link the entries via their OH fields.  */
4715
4716 static struct ppc_link_hash_entry *
4717 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4718 {
4719   struct ppc_link_hash_entry *fdh = fh->oh;
4720
4721   if (fdh == NULL)
4722     {
4723       const char *fd_name = fh->elf.root.root.string + 1;
4724
4725       fdh = (struct ppc_link_hash_entry *)
4726         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4727       if (fdh == NULL)
4728         return fdh;
4729
4730       fdh->is_func_descriptor = 1;
4731       fdh->oh = fh;
4732       fh->is_func = 1;
4733       fh->oh = fdh;
4734     }
4735
4736   return ppc_follow_link (fdh);
4737 }
4738
4739 /* Make a fake function descriptor sym for the code sym FH.  */
4740
4741 static struct ppc_link_hash_entry *
4742 make_fdh (struct bfd_link_info *info,
4743           struct ppc_link_hash_entry *fh)
4744 {
4745   bfd *abfd;
4746   asymbol *newsym;
4747   struct bfd_link_hash_entry *bh;
4748   struct ppc_link_hash_entry *fdh;
4749
4750   abfd = fh->elf.root.u.undef.abfd;
4751   newsym = bfd_make_empty_symbol (abfd);
4752   newsym->name = fh->elf.root.root.string + 1;
4753   newsym->section = bfd_und_section_ptr;
4754   newsym->value = 0;
4755   newsym->flags = BSF_WEAK;
4756
4757   bh = NULL;
4758   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4759                                          newsym->flags, newsym->section,
4760                                          newsym->value, NULL, FALSE, FALSE,
4761                                          &bh))
4762     return NULL;
4763
4764   fdh = (struct ppc_link_hash_entry *) bh;
4765   fdh->elf.non_elf = 0;
4766   fdh->fake = 1;
4767   fdh->is_func_descriptor = 1;
4768   fdh->oh = fh;
4769   fh->is_func = 1;
4770   fh->oh = fdh;
4771   return fdh;
4772 }
4773
4774 /* Fix function descriptor symbols defined in .opd sections to be
4775    function type.  */
4776
4777 static bfd_boolean
4778 ppc64_elf_add_symbol_hook (bfd *ibfd,
4779                            struct bfd_link_info *info,
4780                            Elf_Internal_Sym *isym,
4781                            const char **name,
4782                            flagword *flags ATTRIBUTE_UNUSED,
4783                            asection **sec,
4784                            bfd_vma *value ATTRIBUTE_UNUSED)
4785 {
4786   if ((ibfd->flags & DYNAMIC) == 0
4787       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4788     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4789
4790   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4791     {
4792       if ((ibfd->flags & DYNAMIC) == 0)
4793         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4794     }
4795   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4796     ;
4797   else if (*sec != NULL
4798            && strcmp ((*sec)->name, ".opd") == 0)
4799     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4800
4801   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4802     {
4803       if (abiversion (ibfd) == 0)
4804         set_abiversion (ibfd, 2);
4805       else if (abiversion (ibfd) == 1)
4806         {
4807           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4808                                     " for ABI version 1\n"), name);
4809           bfd_set_error (bfd_error_bad_value);
4810           return FALSE;
4811         }
4812     }
4813
4814   return TRUE;
4815 }
4816
4817 /* Merge non-visibility st_other attributes: local entry point.  */
4818
4819 static void
4820 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4821                                   const Elf_Internal_Sym *isym,
4822                                   bfd_boolean definition,
4823                                   bfd_boolean dynamic)
4824 {
4825   if (definition && !dynamic)
4826     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4827                 | ELF_ST_VISIBILITY (h->other));
4828 }
4829
4830 /* This function makes an old ABI object reference to ".bar" cause the
4831    inclusion of a new ABI object archive that defines "bar".
4832    NAME is a symbol defined in an archive.  Return a symbol in the hash
4833    table that might be satisfied by the archive symbols.  */
4834
4835 static struct elf_link_hash_entry *
4836 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4837                                  struct bfd_link_info *info,
4838                                  const char *name)
4839 {
4840   struct elf_link_hash_entry *h;
4841   char *dot_name;
4842   size_t len;
4843
4844   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4845   if (h != NULL
4846       /* Don't return this sym if it is a fake function descriptor
4847          created by add_symbol_adjust.  */
4848       && !(h->root.type == bfd_link_hash_undefweak
4849            && ((struct ppc_link_hash_entry *) h)->fake))
4850     return h;
4851
4852   if (name[0] == '.')
4853     return h;
4854
4855   len = strlen (name);
4856   dot_name = bfd_alloc (abfd, len + 2);
4857   if (dot_name == NULL)
4858     return (struct elf_link_hash_entry *) 0 - 1;
4859   dot_name[0] = '.';
4860   memcpy (dot_name + 1, name, len + 1);
4861   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4862   bfd_release (abfd, dot_name);
4863   return h;
4864 }
4865
4866 /* This function satisfies all old ABI object references to ".bar" if a
4867    new ABI object defines "bar".  Well, at least, undefined dot symbols
4868    are made weak.  This stops later archive searches from including an
4869    object if we already have a function descriptor definition.  It also
4870    prevents the linker complaining about undefined symbols.
4871    We also check and correct mismatched symbol visibility here.  The
4872    most restrictive visibility of the function descriptor and the
4873    function entry symbol is used.  */
4874
4875 static bfd_boolean
4876 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4877 {
4878   struct ppc_link_hash_table *htab;
4879   struct ppc_link_hash_entry *fdh;
4880
4881   if (eh->elf.root.type == bfd_link_hash_indirect)
4882     return TRUE;
4883
4884   if (eh->elf.root.type == bfd_link_hash_warning)
4885     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4886
4887   if (eh->elf.root.root.string[0] != '.')
4888     abort ();
4889
4890   htab = ppc_hash_table (info);
4891   if (htab == NULL)
4892     return FALSE;
4893
4894   fdh = lookup_fdh (eh, htab);
4895   if (fdh == NULL)
4896     {
4897       if (!info->relocatable
4898           && (eh->elf.root.type == bfd_link_hash_undefined
4899               || eh->elf.root.type == bfd_link_hash_undefweak)
4900           && eh->elf.ref_regular)
4901         {
4902           /* Make an undefweak function descriptor sym, which is enough to
4903              pull in an --as-needed shared lib, but won't cause link
4904              errors.  Archives are handled elsewhere.  */
4905           fdh = make_fdh (info, eh);
4906           if (fdh == NULL)
4907             return FALSE;
4908           fdh->elf.ref_regular = 1;
4909         }
4910     }
4911   else
4912     {
4913       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4914       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4915       if (entry_vis < descr_vis)
4916         fdh->elf.other += entry_vis - descr_vis;
4917       else if (entry_vis > descr_vis)
4918         eh->elf.other += descr_vis - entry_vis;
4919
4920       if ((fdh->elf.root.type == bfd_link_hash_defined
4921            || fdh->elf.root.type == bfd_link_hash_defweak)
4922           && eh->elf.root.type == bfd_link_hash_undefined)
4923         {
4924           eh->elf.root.type = bfd_link_hash_undefweak;
4925           eh->was_undefined = 1;
4926           htab->twiddled_syms = 1;
4927         }
4928     }
4929
4930   return TRUE;
4931 }
4932
4933 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4934
4935 static bfd_boolean
4936 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4937 {
4938   struct ppc_link_hash_table *htab;
4939   struct ppc_link_hash_entry **p, *eh;
4940
4941   if (!is_ppc64_elf (info->output_bfd))
4942     return TRUE;
4943   htab = ppc_hash_table (info);
4944   if (htab == NULL)
4945     return FALSE;
4946
4947   if (is_ppc64_elf (ibfd))
4948     {
4949       p = &htab->dot_syms;
4950       while ((eh = *p) != NULL)
4951         {
4952           *p = NULL;
4953           if (&eh->elf == htab->elf.hgot)
4954             ;
4955           else if (htab->elf.hgot == NULL
4956                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4957             htab->elf.hgot = &eh->elf;
4958           else if (!add_symbol_adjust (eh, info))
4959             return FALSE;
4960           p = &eh->u.next_dot_sym;
4961         }
4962     }
4963
4964   /* Clear the list for non-ppc64 input files.  */
4965   p = &htab->dot_syms;
4966   while ((eh = *p) != NULL)
4967     {
4968       *p = NULL;
4969       p = &eh->u.next_dot_sym;
4970     }
4971
4972   /* We need to fix the undefs list for any syms we have twiddled to
4973      undef_weak.  */
4974   if (htab->twiddled_syms)
4975     {
4976       bfd_link_repair_undef_list (&htab->elf.root);
4977       htab->twiddled_syms = 0;
4978     }
4979   return TRUE;
4980 }
4981
4982 /* Undo hash table changes when an --as-needed input file is determined
4983    not to be needed.  */
4984
4985 static bfd_boolean
4986 ppc64_elf_notice_as_needed (bfd *ibfd,
4987                             struct bfd_link_info *info,
4988                             enum notice_asneeded_action act)
4989 {
4990   if (act == notice_not_needed)
4991     {
4992       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4993
4994       if (htab == NULL)
4995         return FALSE;
4996
4997       htab->dot_syms = NULL;
4998     }
4999   return _bfd_elf_notice_as_needed (ibfd, info, act);
5000 }
5001
5002 /* If --just-symbols against a final linked binary, then assume we need
5003    toc adjusting stubs when calling functions defined there.  */
5004
5005 static void
5006 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5007 {
5008   if ((sec->flags & SEC_CODE) != 0
5009       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5010       && is_ppc64_elf (sec->owner))
5011     {
5012       if (abiversion (sec->owner) >= 2
5013           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5014         sec->has_toc_reloc = 1;
5015     }
5016   _bfd_elf_link_just_syms (sec, info);
5017 }
5018
5019 static struct plt_entry **
5020 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5021                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5022 {
5023   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5024   struct plt_entry **local_plt;
5025   unsigned char *local_got_tls_masks;
5026
5027   if (local_got_ents == NULL)
5028     {
5029       bfd_size_type size = symtab_hdr->sh_info;
5030
5031       size *= (sizeof (*local_got_ents)
5032                + sizeof (*local_plt)
5033                + sizeof (*local_got_tls_masks));
5034       local_got_ents = bfd_zalloc (abfd, size);
5035       if (local_got_ents == NULL)
5036         return NULL;
5037       elf_local_got_ents (abfd) = local_got_ents;
5038     }
5039
5040   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5041     {
5042       struct got_entry *ent;
5043
5044       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5045         if (ent->addend == r_addend
5046             && ent->owner == abfd
5047             && ent->tls_type == tls_type)
5048           break;
5049       if (ent == NULL)
5050         {
5051           bfd_size_type amt = sizeof (*ent);
5052           ent = bfd_alloc (abfd, amt);
5053           if (ent == NULL)
5054             return FALSE;
5055           ent->next = local_got_ents[r_symndx];
5056           ent->addend = r_addend;
5057           ent->owner = abfd;
5058           ent->tls_type = tls_type;
5059           ent->is_indirect = FALSE;
5060           ent->got.refcount = 0;
5061           local_got_ents[r_symndx] = ent;
5062         }
5063       ent->got.refcount += 1;
5064     }
5065
5066   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5067   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5068   local_got_tls_masks[r_symndx] |= tls_type;
5069
5070   return local_plt + r_symndx;
5071 }
5072
5073 static bfd_boolean
5074 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5075 {
5076   struct plt_entry *ent;
5077
5078   for (ent = *plist; ent != NULL; ent = ent->next)
5079     if (ent->addend == addend)
5080       break;
5081   if (ent == NULL)
5082     {
5083       bfd_size_type amt = sizeof (*ent);
5084       ent = bfd_alloc (abfd, amt);
5085       if (ent == NULL)
5086         return FALSE;
5087       ent->next = *plist;
5088       ent->addend = addend;
5089       ent->plt.refcount = 0;
5090       *plist = ent;
5091     }
5092   ent->plt.refcount += 1;
5093   return TRUE;
5094 }
5095
5096 static bfd_boolean
5097 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5098 {
5099   return (r_type == R_PPC64_REL24
5100           || r_type == R_PPC64_REL14
5101           || r_type == R_PPC64_REL14_BRTAKEN
5102           || r_type == R_PPC64_REL14_BRNTAKEN
5103           || r_type == R_PPC64_ADDR24
5104           || r_type == R_PPC64_ADDR14
5105           || r_type == R_PPC64_ADDR14_BRTAKEN
5106           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5107 }
5108
5109 /* Look through the relocs for a section during the first phase, and
5110    calculate needed space in the global offset table, procedure
5111    linkage table, and dynamic reloc sections.  */
5112
5113 static bfd_boolean
5114 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5115                         asection *sec, const Elf_Internal_Rela *relocs)
5116 {
5117   struct ppc_link_hash_table *htab;
5118   Elf_Internal_Shdr *symtab_hdr;
5119   struct elf_link_hash_entry **sym_hashes;
5120   const Elf_Internal_Rela *rel;
5121   const Elf_Internal_Rela *rel_end;
5122   asection *sreloc;
5123   asection **opd_sym_map;
5124   struct elf_link_hash_entry *tga, *dottga;
5125
5126   if (info->relocatable)
5127     return TRUE;
5128
5129   /* Don't do anything special with non-loaded, non-alloced sections.
5130      In particular, any relocs in such sections should not affect GOT
5131      and PLT reference counting (ie. we don't allow them to create GOT
5132      or PLT entries), there's no possibility or desire to optimize TLS
5133      relocs, and there's not much point in propagating relocs to shared
5134      libs that the dynamic linker won't relocate.  */
5135   if ((sec->flags & SEC_ALLOC) == 0)
5136     return TRUE;
5137
5138   BFD_ASSERT (is_ppc64_elf (abfd));
5139
5140   htab = ppc_hash_table (info);
5141   if (htab == NULL)
5142     return FALSE;
5143
5144   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5145                               FALSE, FALSE, TRUE);
5146   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5147                                  FALSE, FALSE, TRUE);
5148   symtab_hdr = &elf_symtab_hdr (abfd);
5149   sym_hashes = elf_sym_hashes (abfd);
5150   sreloc = NULL;
5151   opd_sym_map = NULL;
5152   if (strcmp (sec->name, ".opd") == 0)
5153     {
5154       /* Garbage collection needs some extra help with .opd sections.
5155          We don't want to necessarily keep everything referenced by
5156          relocs in .opd, as that would keep all functions.  Instead,
5157          if we reference an .opd symbol (a function descriptor), we
5158          want to keep the function code symbol's section.  This is
5159          easy for global symbols, but for local syms we need to keep
5160          information about the associated function section.  */
5161       bfd_size_type amt;
5162
5163       if (abiversion (abfd) == 0)
5164         set_abiversion (abfd, 1);
5165       else if (abiversion (abfd) == 2)
5166         {
5167           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5168                                   abiversion (abfd));
5169           bfd_set_error (bfd_error_bad_value);
5170           return FALSE;
5171         }
5172       amt = sec->size * sizeof (*opd_sym_map) / 8;
5173       opd_sym_map = bfd_zalloc (abfd, amt);
5174       if (opd_sym_map == NULL)
5175         return FALSE;
5176       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5177       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5178       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5179     }
5180
5181   rel_end = relocs + sec->reloc_count;
5182   for (rel = relocs; rel < rel_end; rel++)
5183     {
5184       unsigned long r_symndx;
5185       struct elf_link_hash_entry *h;
5186       enum elf_ppc64_reloc_type r_type;
5187       int tls_type;
5188       struct _ppc64_elf_section_data *ppc64_sec;
5189       struct plt_entry **ifunc;
5190
5191       r_symndx = ELF64_R_SYM (rel->r_info);
5192       if (r_symndx < symtab_hdr->sh_info)
5193         h = NULL;
5194       else
5195         {
5196           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5197           h = elf_follow_link (h);
5198
5199           /* PR15323, ref flags aren't set for references in the same
5200              object.  */
5201           h->root.non_ir_ref = 1;
5202
5203           if (h == htab->elf.hgot)
5204             sec->has_toc_reloc = 1;
5205         }
5206
5207       tls_type = 0;
5208       ifunc = NULL;
5209       if (h != NULL)
5210         {
5211           if (h->type == STT_GNU_IFUNC)
5212             {
5213               h->needs_plt = 1;
5214               ifunc = &h->plt.plist;
5215             }
5216         }
5217       else
5218         {
5219           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5220                                                           abfd, r_symndx);
5221           if (isym == NULL)
5222             return FALSE;
5223
5224           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5225             {
5226               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5227                                              rel->r_addend, PLT_IFUNC);
5228               if (ifunc == NULL)
5229                 return FALSE;
5230             }
5231         }
5232       r_type = ELF64_R_TYPE (rel->r_info);
5233       if (is_branch_reloc (r_type))
5234         {
5235           if (h != NULL && (h == tga || h == dottga))
5236             {
5237               if (rel != relocs
5238                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5239                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5240                 /* We have a new-style __tls_get_addr call with a marker
5241                    reloc.  */
5242                 ;
5243               else
5244                 /* Mark this section as having an old-style call.  */
5245                 sec->has_tls_get_addr_call = 1;
5246             }
5247
5248           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5249           if (ifunc != NULL
5250               && !update_plt_info (abfd, ifunc, rel->r_addend))
5251             return FALSE;
5252         }
5253
5254       switch (r_type)
5255         {
5256         case R_PPC64_TLSGD:
5257         case R_PPC64_TLSLD:
5258           /* These special tls relocs tie a call to __tls_get_addr with
5259              its parameter symbol.  */
5260           break;
5261
5262         case R_PPC64_GOT_TLSLD16:
5263         case R_PPC64_GOT_TLSLD16_LO:
5264         case R_PPC64_GOT_TLSLD16_HI:
5265         case R_PPC64_GOT_TLSLD16_HA:
5266           tls_type = TLS_TLS | TLS_LD;
5267           goto dogottls;
5268
5269         case R_PPC64_GOT_TLSGD16:
5270         case R_PPC64_GOT_TLSGD16_LO:
5271         case R_PPC64_GOT_TLSGD16_HI:
5272         case R_PPC64_GOT_TLSGD16_HA:
5273           tls_type = TLS_TLS | TLS_GD;
5274           goto dogottls;
5275
5276         case R_PPC64_GOT_TPREL16_DS:
5277         case R_PPC64_GOT_TPREL16_LO_DS:
5278         case R_PPC64_GOT_TPREL16_HI:
5279         case R_PPC64_GOT_TPREL16_HA:
5280           if (!info->executable)
5281             info->flags |= DF_STATIC_TLS;
5282           tls_type = TLS_TLS | TLS_TPREL;
5283           goto dogottls;
5284
5285         case R_PPC64_GOT_DTPREL16_DS:
5286         case R_PPC64_GOT_DTPREL16_LO_DS:
5287         case R_PPC64_GOT_DTPREL16_HI:
5288         case R_PPC64_GOT_DTPREL16_HA:
5289           tls_type = TLS_TLS | TLS_DTPREL;
5290         dogottls:
5291           sec->has_tls_reloc = 1;
5292           /* Fall thru */
5293
5294         case R_PPC64_GOT16:
5295         case R_PPC64_GOT16_DS:
5296         case R_PPC64_GOT16_HA:
5297         case R_PPC64_GOT16_HI:
5298         case R_PPC64_GOT16_LO:
5299         case R_PPC64_GOT16_LO_DS:
5300           /* This symbol requires a global offset table entry.  */
5301           sec->has_toc_reloc = 1;
5302           if (r_type == R_PPC64_GOT_TLSLD16
5303               || r_type == R_PPC64_GOT_TLSGD16
5304               || r_type == R_PPC64_GOT_TPREL16_DS
5305               || r_type == R_PPC64_GOT_DTPREL16_DS
5306               || r_type == R_PPC64_GOT16
5307               || r_type == R_PPC64_GOT16_DS)
5308             {
5309               htab->do_multi_toc = 1;
5310               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5311             }
5312
5313           if (ppc64_elf_tdata (abfd)->got == NULL
5314               && !create_got_section (abfd, info))
5315             return FALSE;
5316
5317           if (h != NULL)
5318             {
5319               struct ppc_link_hash_entry *eh;
5320               struct got_entry *ent;
5321
5322               eh = (struct ppc_link_hash_entry *) h;
5323               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5324                 if (ent->addend == rel->r_addend
5325                     && ent->owner == abfd
5326                     && ent->tls_type == tls_type)
5327                   break;
5328               if (ent == NULL)
5329                 {
5330                   bfd_size_type amt = sizeof (*ent);
5331                   ent = bfd_alloc (abfd, amt);
5332                   if (ent == NULL)
5333                     return FALSE;
5334                   ent->next = eh->elf.got.glist;
5335                   ent->addend = rel->r_addend;
5336                   ent->owner = abfd;
5337                   ent->tls_type = tls_type;
5338                   ent->is_indirect = FALSE;
5339                   ent->got.refcount = 0;
5340                   eh->elf.got.glist = ent;
5341                 }
5342               ent->got.refcount += 1;
5343               eh->tls_mask |= tls_type;
5344             }
5345           else
5346             /* This is a global offset table entry for a local symbol.  */
5347             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5348                                         rel->r_addend, tls_type))
5349               return FALSE;
5350
5351           /* We may also need a plt entry if the symbol turns out to be
5352              an ifunc.  */
5353           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5354             {
5355               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5356                 return FALSE;
5357             }
5358           break;
5359
5360         case R_PPC64_PLT16_HA:
5361         case R_PPC64_PLT16_HI:
5362         case R_PPC64_PLT16_LO:
5363         case R_PPC64_PLT32:
5364         case R_PPC64_PLT64:
5365           /* This symbol requires a procedure linkage table entry.  We
5366              actually build the entry in adjust_dynamic_symbol,
5367              because this might be a case of linking PIC code without
5368              linking in any dynamic objects, in which case we don't
5369              need to generate a procedure linkage table after all.  */
5370           if (h == NULL)
5371             {
5372               /* It does not make sense to have a procedure linkage
5373                  table entry for a local symbol.  */
5374               bfd_set_error (bfd_error_bad_value);
5375               return FALSE;
5376             }
5377           else
5378             {
5379               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5380                 return FALSE;
5381               h->needs_plt = 1;
5382               if (h->root.root.string[0] == '.'
5383                   && h->root.root.string[1] != '\0')
5384                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5385             }
5386           break;
5387
5388           /* The following relocations don't need to propagate the
5389              relocation if linking a shared object since they are
5390              section relative.  */
5391         case R_PPC64_SECTOFF:
5392         case R_PPC64_SECTOFF_LO:
5393         case R_PPC64_SECTOFF_HI:
5394         case R_PPC64_SECTOFF_HA:
5395         case R_PPC64_SECTOFF_DS:
5396         case R_PPC64_SECTOFF_LO_DS:
5397         case R_PPC64_DTPREL16:
5398         case R_PPC64_DTPREL16_LO:
5399         case R_PPC64_DTPREL16_HI:
5400         case R_PPC64_DTPREL16_HA:
5401         case R_PPC64_DTPREL16_DS:
5402         case R_PPC64_DTPREL16_LO_DS:
5403         case R_PPC64_DTPREL16_HIGH:
5404         case R_PPC64_DTPREL16_HIGHA:
5405         case R_PPC64_DTPREL16_HIGHER:
5406         case R_PPC64_DTPREL16_HIGHERA:
5407         case R_PPC64_DTPREL16_HIGHEST:
5408         case R_PPC64_DTPREL16_HIGHESTA:
5409           break;
5410
5411           /* Nor do these.  */
5412         case R_PPC64_REL16:
5413         case R_PPC64_REL16_LO:
5414         case R_PPC64_REL16_HI:
5415         case R_PPC64_REL16_HA:
5416           break;
5417
5418           /* Not supported as a dynamic relocation.  */
5419         case R_PPC64_ADDR64_LOCAL:
5420           if (info->shared)
5421             {
5422               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5423                 ppc_howto_init ();
5424               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5425                                         "in shared libraries and PIEs.\n"),
5426                                       abfd, sec, rel->r_offset,
5427                                       ppc64_elf_howto_table[r_type]->name);
5428               bfd_set_error (bfd_error_bad_value);
5429               return FALSE;
5430             }
5431           break;
5432
5433         case R_PPC64_TOC16:
5434         case R_PPC64_TOC16_DS:
5435           htab->do_multi_toc = 1;
5436           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5437         case R_PPC64_TOC16_LO:
5438         case R_PPC64_TOC16_HI:
5439         case R_PPC64_TOC16_HA:
5440         case R_PPC64_TOC16_LO_DS:
5441           sec->has_toc_reloc = 1;
5442           break;
5443
5444           /* This relocation describes the C++ object vtable hierarchy.
5445              Reconstruct it for later use during GC.  */
5446         case R_PPC64_GNU_VTINHERIT:
5447           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5448             return FALSE;
5449           break;
5450
5451           /* This relocation describes which C++ vtable entries are actually
5452              used.  Record for later use during GC.  */
5453         case R_PPC64_GNU_VTENTRY:
5454           BFD_ASSERT (h != NULL);
5455           if (h != NULL
5456               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5457             return FALSE;
5458           break;
5459
5460         case R_PPC64_REL14:
5461         case R_PPC64_REL14_BRTAKEN:
5462         case R_PPC64_REL14_BRNTAKEN:
5463           {
5464             asection *dest = NULL;
5465
5466             /* Heuristic: If jumping outside our section, chances are
5467                we are going to need a stub.  */
5468             if (h != NULL)
5469               {
5470                 /* If the sym is weak it may be overridden later, so
5471                    don't assume we know where a weak sym lives.  */
5472                 if (h->root.type == bfd_link_hash_defined)
5473                   dest = h->root.u.def.section;
5474               }
5475             else
5476               {
5477                 Elf_Internal_Sym *isym;
5478
5479                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5480                                               abfd, r_symndx);
5481                 if (isym == NULL)
5482                   return FALSE;
5483
5484                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5485               }
5486
5487             if (dest != sec)
5488               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5489           }
5490           /* Fall through.  */
5491
5492         case R_PPC64_REL24:
5493           if (h != NULL && ifunc == NULL)
5494             {
5495               /* We may need a .plt entry if the function this reloc
5496                  refers to is in a shared lib.  */
5497               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5498                 return FALSE;
5499               h->needs_plt = 1;
5500               if (h->root.root.string[0] == '.'
5501                   && h->root.root.string[1] != '\0')
5502                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5503               if (h == tga || h == dottga)
5504                 sec->has_tls_reloc = 1;
5505             }
5506           break;
5507
5508         case R_PPC64_TPREL64:
5509           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5510           if (!info->executable)
5511             info->flags |= DF_STATIC_TLS;
5512           goto dotlstoc;
5513
5514         case R_PPC64_DTPMOD64:
5515           if (rel + 1 < rel_end
5516               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5517               && rel[1].r_offset == rel->r_offset + 8)
5518             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5519           else
5520             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5521           goto dotlstoc;
5522
5523         case R_PPC64_DTPREL64:
5524           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5525           if (rel != relocs
5526               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5527               && rel[-1].r_offset == rel->r_offset - 8)
5528             /* This is the second reloc of a dtpmod, dtprel pair.
5529                Don't mark with TLS_DTPREL.  */
5530             goto dodyn;
5531
5532         dotlstoc:
5533           sec->has_tls_reloc = 1;
5534           if (h != NULL)
5535             {
5536               struct ppc_link_hash_entry *eh;
5537               eh = (struct ppc_link_hash_entry *) h;
5538               eh->tls_mask |= tls_type;
5539             }
5540           else
5541             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5542                                         rel->r_addend, tls_type))
5543               return FALSE;
5544
5545           ppc64_sec = ppc64_elf_section_data (sec);
5546           if (ppc64_sec->sec_type != sec_toc)
5547             {
5548               bfd_size_type amt;
5549
5550               /* One extra to simplify get_tls_mask.  */
5551               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5552               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5553               if (ppc64_sec->u.toc.symndx == NULL)
5554                 return FALSE;
5555               amt = sec->size * sizeof (bfd_vma) / 8;
5556               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5557               if (ppc64_sec->u.toc.add == NULL)
5558                 return FALSE;
5559               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5560               ppc64_sec->sec_type = sec_toc;
5561             }
5562           BFD_ASSERT (rel->r_offset % 8 == 0);
5563           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5564           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5565
5566           /* Mark the second slot of a GD or LD entry.
5567              -1 to indicate GD and -2 to indicate LD.  */
5568           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5569             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5570           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5571             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5572           goto dodyn;
5573
5574         case R_PPC64_TPREL16:
5575         case R_PPC64_TPREL16_LO:
5576         case R_PPC64_TPREL16_HI:
5577         case R_PPC64_TPREL16_HA:
5578         case R_PPC64_TPREL16_DS:
5579         case R_PPC64_TPREL16_LO_DS:
5580         case R_PPC64_TPREL16_HIGH:
5581         case R_PPC64_TPREL16_HIGHA:
5582         case R_PPC64_TPREL16_HIGHER:
5583         case R_PPC64_TPREL16_HIGHERA:
5584         case R_PPC64_TPREL16_HIGHEST:
5585         case R_PPC64_TPREL16_HIGHESTA:
5586           if (info->shared)
5587             {
5588               if (!info->executable)
5589                 info->flags |= DF_STATIC_TLS;
5590               goto dodyn;
5591             }
5592           break;
5593
5594         case R_PPC64_ADDR64:
5595           if (opd_sym_map != NULL
5596               && rel + 1 < rel_end
5597               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5598             {
5599               if (h != NULL)
5600                 {
5601                   if (h->root.root.string[0] == '.'
5602                       && h->root.root.string[1] != 0
5603                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5604                     ;
5605                   else
5606                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5607                 }
5608               else
5609                 {
5610                   asection *s;
5611                   Elf_Internal_Sym *isym;
5612
5613                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5614                                                 abfd, r_symndx);
5615                   if (isym == NULL)
5616                     return FALSE;
5617
5618                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5619                   if (s != NULL && s != sec)
5620                     opd_sym_map[rel->r_offset / 8] = s;
5621                 }
5622             }
5623           /* Fall through.  */
5624
5625         case R_PPC64_ADDR16:
5626         case R_PPC64_ADDR16_DS:
5627         case R_PPC64_ADDR16_HA:
5628         case R_PPC64_ADDR16_HI:
5629         case R_PPC64_ADDR16_HIGH:
5630         case R_PPC64_ADDR16_HIGHA:
5631         case R_PPC64_ADDR16_HIGHER:
5632         case R_PPC64_ADDR16_HIGHERA:
5633         case R_PPC64_ADDR16_HIGHEST:
5634         case R_PPC64_ADDR16_HIGHESTA:
5635         case R_PPC64_ADDR16_LO:
5636         case R_PPC64_ADDR16_LO_DS:
5637           if (h != NULL && !info->shared && abiversion (abfd) == 2
5638               && rel->r_addend == 0)
5639             {
5640               /* We may need a .plt entry if this reloc refers to a
5641                  function in a shared lib.  */
5642               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5643                 return FALSE;
5644               h->pointer_equality_needed = 1;
5645             }
5646           /* Fall through.  */
5647
5648         case R_PPC64_REL30:
5649         case R_PPC64_REL32:
5650         case R_PPC64_REL64:
5651         case R_PPC64_ADDR14:
5652         case R_PPC64_ADDR14_BRNTAKEN:
5653         case R_PPC64_ADDR14_BRTAKEN:
5654         case R_PPC64_ADDR24:
5655         case R_PPC64_ADDR32:
5656         case R_PPC64_UADDR16:
5657         case R_PPC64_UADDR32:
5658         case R_PPC64_UADDR64:
5659         case R_PPC64_TOC:
5660           if (h != NULL && !info->shared)
5661             /* We may need a copy reloc.  */
5662             h->non_got_ref = 1;
5663
5664           /* Don't propagate .opd relocs.  */
5665           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5666             break;
5667
5668           /* If we are creating a shared library, and this is a reloc
5669              against a global symbol, or a non PC relative reloc
5670              against a local symbol, then we need to copy the reloc
5671              into the shared library.  However, if we are linking with
5672              -Bsymbolic, we do not need to copy a reloc against a
5673              global symbol which is defined in an object we are
5674              including in the link (i.e., DEF_REGULAR is set).  At
5675              this point we have not seen all the input files, so it is
5676              possible that DEF_REGULAR is not set now but will be set
5677              later (it is never cleared).  In case of a weak definition,
5678              DEF_REGULAR may be cleared later by a strong definition in
5679              a shared library.  We account for that possibility below by
5680              storing information in the dyn_relocs field of the hash
5681              table entry.  A similar situation occurs when creating
5682              shared libraries and symbol visibility changes render the
5683              symbol local.
5684
5685              If on the other hand, we are creating an executable, we
5686              may need to keep relocations for symbols satisfied by a
5687              dynamic library if we manage to avoid copy relocs for the
5688              symbol.  */
5689         dodyn:
5690           if ((info->shared
5691                && (must_be_dyn_reloc (info, r_type)
5692                    || (h != NULL
5693                        && (!SYMBOLIC_BIND (info, h)
5694                            || h->root.type == bfd_link_hash_defweak
5695                            || !h->def_regular))))
5696               || (ELIMINATE_COPY_RELOCS
5697                   && !info->shared
5698                   && h != NULL
5699                   && (h->root.type == bfd_link_hash_defweak
5700                       || !h->def_regular))
5701               || (!info->shared
5702                   && ifunc != NULL))
5703             {
5704               /* We must copy these reloc types into the output file.
5705                  Create a reloc section in dynobj and make room for
5706                  this reloc.  */
5707               if (sreloc == NULL)
5708                 {
5709                   sreloc = _bfd_elf_make_dynamic_reloc_section
5710                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5711
5712                   if (sreloc == NULL)
5713                     return FALSE;
5714                 }
5715
5716               /* If this is a global symbol, we count the number of
5717                  relocations we need for this symbol.  */
5718               if (h != NULL)
5719                 {
5720                   struct elf_dyn_relocs *p;
5721                   struct elf_dyn_relocs **head;
5722
5723                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5724                   p = *head;
5725                   if (p == NULL || p->sec != sec)
5726                     {
5727                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5728                       if (p == NULL)
5729                         return FALSE;
5730                       p->next = *head;
5731                       *head = p;
5732                       p->sec = sec;
5733                       p->count = 0;
5734                       p->pc_count = 0;
5735                     }
5736                   p->count += 1;
5737                   if (!must_be_dyn_reloc (info, r_type))
5738                     p->pc_count += 1;
5739                 }
5740               else
5741                 {
5742                   /* Track dynamic relocs needed for local syms too.
5743                      We really need local syms available to do this
5744                      easily.  Oh well.  */
5745                   struct ppc_dyn_relocs *p;
5746                   struct ppc_dyn_relocs **head;
5747                   bfd_boolean is_ifunc;
5748                   asection *s;
5749                   void *vpp;
5750                   Elf_Internal_Sym *isym;
5751
5752                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5753                                                 abfd, r_symndx);
5754                   if (isym == NULL)
5755                     return FALSE;
5756
5757                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5758                   if (s == NULL)
5759                     s = sec;
5760
5761                   vpp = &elf_section_data (s)->local_dynrel;
5762                   head = (struct ppc_dyn_relocs **) vpp;
5763                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5764                   p = *head;
5765                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5766                     p = p->next;
5767                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5768                     {
5769                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5770                       if (p == NULL)
5771                         return FALSE;
5772                       p->next = *head;
5773                       *head = p;
5774                       p->sec = sec;
5775                       p->ifunc = is_ifunc;
5776                       p->count = 0;
5777                     }
5778                   p->count += 1;
5779                 }
5780             }
5781           break;
5782
5783         default:
5784           break;
5785         }
5786     }
5787
5788   return TRUE;
5789 }
5790
5791 /* Merge backend specific data from an object file to the output
5792    object file when linking.  */
5793
5794 static bfd_boolean
5795 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5796 {
5797   unsigned long iflags, oflags;
5798
5799   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5800     return TRUE;
5801
5802   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5803     return TRUE;
5804
5805   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5806     return FALSE;
5807
5808   iflags = elf_elfheader (ibfd)->e_flags;
5809   oflags = elf_elfheader (obfd)->e_flags;
5810
5811   if (!elf_flags_init (obfd) || oflags == 0)
5812     {
5813       elf_flags_init (obfd) = TRUE;
5814       elf_elfheader (obfd)->e_flags = iflags;
5815     }
5816   else if (iflags == oflags || iflags == 0)
5817     ;
5818   else if (iflags & ~EF_PPC64_ABI)
5819     {
5820       (*_bfd_error_handler)
5821         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5822       bfd_set_error (bfd_error_bad_value);
5823       return FALSE;
5824     }
5825   else
5826     {
5827       (*_bfd_error_handler)
5828         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5829          ibfd, iflags, oflags);
5830       bfd_set_error (bfd_error_bad_value);
5831       return FALSE;
5832     }
5833
5834   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5835   _bfd_elf_merge_object_attributes (ibfd, obfd);
5836
5837   return TRUE;
5838 }
5839
5840 static bfd_boolean
5841 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5842 {
5843   /* Print normal ELF private data.  */
5844   _bfd_elf_print_private_bfd_data (abfd, ptr);
5845
5846   if (elf_elfheader (abfd)->e_flags != 0)
5847     {
5848       FILE *file = ptr;
5849
5850       /* xgettext:c-format */
5851       fprintf (file, _("private flags = 0x%lx:"),
5852                elf_elfheader (abfd)->e_flags);
5853
5854       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5855         fprintf (file, _(" [abiv%ld]"),
5856                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5857       fputc ('\n', file);
5858     }
5859
5860   return TRUE;
5861 }
5862
5863 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5864    of the code entry point, and its section.  */
5865
5866 static bfd_vma
5867 opd_entry_value (asection *opd_sec,
5868                  bfd_vma offset,
5869                  asection **code_sec,
5870                  bfd_vma *code_off,
5871                  bfd_boolean in_code_sec)
5872 {
5873   bfd *opd_bfd = opd_sec->owner;
5874   Elf_Internal_Rela *relocs;
5875   Elf_Internal_Rela *lo, *hi, *look;
5876   bfd_vma val;
5877
5878   /* No relocs implies we are linking a --just-symbols object, or looking
5879      at a final linked executable with addr2line or somesuch.  */
5880   if (opd_sec->reloc_count == 0)
5881     {
5882       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5883
5884       if (contents == NULL)
5885         {
5886           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5887             return (bfd_vma) -1;
5888           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5889         }
5890
5891       val = bfd_get_64 (opd_bfd, contents + offset);
5892       if (code_sec != NULL)
5893         {
5894           asection *sec, *likely = NULL;
5895
5896           if (in_code_sec)
5897             {
5898               sec = *code_sec;
5899               if (sec->vma <= val
5900                   && val < sec->vma + sec->size)
5901                 likely = sec;
5902               else
5903                 val = -1;
5904             }
5905           else
5906             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5907               if (sec->vma <= val
5908                   && (sec->flags & SEC_LOAD) != 0
5909                   && (sec->flags & SEC_ALLOC) != 0)
5910                 likely = sec;
5911           if (likely != NULL)
5912             {
5913               *code_sec = likely;
5914               if (code_off != NULL)
5915                 *code_off = val - likely->vma;
5916             }
5917         }
5918       return val;
5919     }
5920
5921   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5922
5923   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5924   if (relocs == NULL)
5925     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5926
5927   /* Go find the opd reloc at the sym address.  */
5928   lo = relocs;
5929   BFD_ASSERT (lo != NULL);
5930   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5931   val = (bfd_vma) -1;
5932   while (lo < hi)
5933     {
5934       look = lo + (hi - lo) / 2;
5935       if (look->r_offset < offset)
5936         lo = look + 1;
5937       else if (look->r_offset > offset)
5938         hi = look;
5939       else
5940         {
5941           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5942
5943           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5944               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5945             {
5946               unsigned long symndx = ELF64_R_SYM (look->r_info);
5947               asection *sec;
5948
5949               if (symndx < symtab_hdr->sh_info
5950                   || elf_sym_hashes (opd_bfd) == NULL)
5951                 {
5952                   Elf_Internal_Sym *sym;
5953
5954                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5955                   if (sym == NULL)
5956                     {
5957                       size_t symcnt = symtab_hdr->sh_info;
5958                       if (elf_sym_hashes (opd_bfd) == NULL)
5959                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5960                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5961                                                   0, NULL, NULL, NULL);
5962                       if (sym == NULL)
5963                         break;
5964                       symtab_hdr->contents = (bfd_byte *) sym;
5965                     }
5966
5967                   sym += symndx;
5968                   val = sym->st_value;
5969                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5970                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5971                 }
5972               else
5973                 {
5974                   struct elf_link_hash_entry **sym_hashes;
5975                   struct elf_link_hash_entry *rh;
5976
5977                   sym_hashes = elf_sym_hashes (opd_bfd);
5978                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5979                   if (rh != NULL)
5980                     {
5981                       rh = elf_follow_link (rh);
5982                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5983                                   || rh->root.type == bfd_link_hash_defweak);
5984                       val = rh->root.u.def.value;
5985                       sec = rh->root.u.def.section;
5986                     }
5987                   else
5988                     {
5989                       /* Handle the odd case where we can be called
5990                          during bfd_elf_link_add_symbols before the
5991                          symbol hashes have been fully populated.  */
5992                       Elf_Internal_Sym *sym;
5993
5994                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5995                                                   symndx, NULL, NULL, NULL);
5996                       if (sym == NULL)
5997                         break;
5998
5999                       val = sym->st_value;
6000                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6001                       free (sym);
6002                     }
6003                 }
6004               val += look->r_addend;
6005               if (code_off != NULL)
6006                 *code_off = val;
6007               if (code_sec != NULL)
6008                 {
6009                   if (in_code_sec && *code_sec != sec)
6010                     return -1;
6011                   else
6012                     *code_sec = sec;
6013                 }
6014               if (sec != NULL && sec->output_section != NULL)
6015                 val += sec->output_section->vma + sec->output_offset;
6016             }
6017           break;
6018         }
6019     }
6020
6021   return val;
6022 }
6023
6024 /* If the ELF symbol SYM might be a function in SEC, return the
6025    function size and set *CODE_OFF to the function's entry point,
6026    otherwise return zero.  */
6027
6028 static bfd_size_type
6029 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6030                               bfd_vma *code_off)
6031 {
6032   bfd_size_type size;
6033
6034   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6035                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6036     return 0;
6037
6038   size = 0;
6039   if (!(sym->flags & BSF_SYNTHETIC))
6040     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6041
6042   if (strcmp (sym->section->name, ".opd") == 0)
6043     {
6044       if (opd_entry_value (sym->section, sym->value,
6045                            &sec, code_off, TRUE) == (bfd_vma) -1)
6046         return 0;
6047       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6048          symbol.  This size has nothing to do with the code size of the
6049          function, which is what we're supposed to return, but the
6050          code size isn't available without looking up the dot-sym.
6051          However, doing that would be a waste of time particularly
6052          since elf_find_function will look at the dot-sym anyway.
6053          Now, elf_find_function will keep the largest size of any
6054          function sym found at the code address of interest, so return
6055          1 here to avoid it incorrectly caching a larger function size
6056          for a small function.  This does mean we return the wrong
6057          size for a new-ABI function of size 24, but all that does is
6058          disable caching for such functions.  */
6059       if (size == 24)
6060         size = 1;
6061     }
6062   else
6063     {
6064       if (sym->section != sec)
6065         return 0;
6066       *code_off = sym->value;
6067     }
6068   if (size == 0)
6069     size = 1;
6070   return size;
6071 }
6072
6073 /* Return true if symbol is defined in a regular object file.  */
6074
6075 static bfd_boolean
6076 is_static_defined (struct elf_link_hash_entry *h)
6077 {
6078   return ((h->root.type == bfd_link_hash_defined
6079            || h->root.type == bfd_link_hash_defweak)
6080           && h->root.u.def.section != NULL
6081           && h->root.u.def.section->output_section != NULL);
6082 }
6083
6084 /* If FDH is a function descriptor symbol, return the associated code
6085    entry symbol if it is defined.  Return NULL otherwise.  */
6086
6087 static struct ppc_link_hash_entry *
6088 defined_code_entry (struct ppc_link_hash_entry *fdh)
6089 {
6090   if (fdh->is_func_descriptor)
6091     {
6092       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6093       if (fh->elf.root.type == bfd_link_hash_defined
6094           || fh->elf.root.type == bfd_link_hash_defweak)
6095         return fh;
6096     }
6097   return NULL;
6098 }
6099
6100 /* If FH is a function code entry symbol, return the associated
6101    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6102
6103 static struct ppc_link_hash_entry *
6104 defined_func_desc (struct ppc_link_hash_entry *fh)
6105 {
6106   if (fh->oh != NULL
6107       && fh->oh->is_func_descriptor)
6108     {
6109       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6110       if (fdh->elf.root.type == bfd_link_hash_defined
6111           || fdh->elf.root.type == bfd_link_hash_defweak)
6112         return fdh;
6113     }
6114   return NULL;
6115 }
6116
6117 /* Mark all our entry sym sections, both opd and code section.  */
6118
6119 static void
6120 ppc64_elf_gc_keep (struct bfd_link_info *info)
6121 {
6122   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6123   struct bfd_sym_chain *sym;
6124
6125   if (htab == NULL)
6126     return;
6127
6128   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6129     {
6130       struct ppc_link_hash_entry *eh, *fh;
6131       asection *sec;
6132
6133       eh = (struct ppc_link_hash_entry *)
6134         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6135       if (eh == NULL)
6136         continue;
6137       if (eh->elf.root.type != bfd_link_hash_defined
6138           && eh->elf.root.type != bfd_link_hash_defweak)
6139         continue;
6140
6141       fh = defined_code_entry (eh);
6142       if (fh != NULL)
6143         {
6144           sec = fh->elf.root.u.def.section;
6145           sec->flags |= SEC_KEEP;
6146         }
6147       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6148                && opd_entry_value (eh->elf.root.u.def.section,
6149                                    eh->elf.root.u.def.value,
6150                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6151         sec->flags |= SEC_KEEP;
6152
6153       sec = eh->elf.root.u.def.section;
6154       sec->flags |= SEC_KEEP;
6155     }
6156 }
6157
6158 /* Mark sections containing dynamically referenced symbols.  When
6159    building shared libraries, we must assume that any visible symbol is
6160    referenced.  */
6161
6162 static bfd_boolean
6163 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6164 {
6165   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6166   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6167   struct ppc_link_hash_entry *fdh;
6168   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6169
6170   /* Dynamic linking info is on the func descriptor sym.  */
6171   fdh = defined_func_desc (eh);
6172   if (fdh != NULL)
6173     eh = fdh;
6174
6175   if ((eh->elf.root.type == bfd_link_hash_defined
6176        || eh->elf.root.type == bfd_link_hash_defweak)
6177       && (eh->elf.ref_dynamic
6178           || (eh->elf.def_regular
6179               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6180               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6181               && (!info->executable
6182                   || info->export_dynamic
6183                   || (eh->elf.dynamic
6184                       && d != NULL
6185                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6186               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6187                   || !bfd_hide_sym_by_version (info->version_info,
6188                                                eh->elf.root.root.string)))))
6189     {
6190       asection *code_sec;
6191       struct ppc_link_hash_entry *fh;
6192
6193       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6194
6195       /* Function descriptor syms cause the associated
6196          function code sym section to be marked.  */
6197       fh = defined_code_entry (eh);
6198       if (fh != NULL)
6199         {
6200           code_sec = fh->elf.root.u.def.section;
6201           code_sec->flags |= SEC_KEEP;
6202         }
6203       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6204                && opd_entry_value (eh->elf.root.u.def.section,
6205                                    eh->elf.root.u.def.value,
6206                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6207         code_sec->flags |= SEC_KEEP;
6208     }
6209
6210   return TRUE;
6211 }
6212
6213 /* Return the section that should be marked against GC for a given
6214    relocation.  */
6215
6216 static asection *
6217 ppc64_elf_gc_mark_hook (asection *sec,
6218                         struct bfd_link_info *info,
6219                         Elf_Internal_Rela *rel,
6220                         struct elf_link_hash_entry *h,
6221                         Elf_Internal_Sym *sym)
6222 {
6223   asection *rsec;
6224
6225   /* Syms return NULL if we're marking .opd, so we avoid marking all
6226      function sections, as all functions are referenced in .opd.  */
6227   rsec = NULL;
6228   if (get_opd_info (sec) != NULL)
6229     return rsec;
6230
6231   if (h != NULL)
6232     {
6233       enum elf_ppc64_reloc_type r_type;
6234       struct ppc_link_hash_entry *eh, *fh, *fdh;
6235
6236       r_type = ELF64_R_TYPE (rel->r_info);
6237       switch (r_type)
6238         {
6239         case R_PPC64_GNU_VTINHERIT:
6240         case R_PPC64_GNU_VTENTRY:
6241           break;
6242
6243         default:
6244           switch (h->root.type)
6245             {
6246             case bfd_link_hash_defined:
6247             case bfd_link_hash_defweak:
6248               eh = (struct ppc_link_hash_entry *) h;
6249               fdh = defined_func_desc (eh);
6250               if (fdh != NULL)
6251                 eh = fdh;
6252
6253               /* Function descriptor syms cause the associated
6254                  function code sym section to be marked.  */
6255               fh = defined_code_entry (eh);
6256               if (fh != NULL)
6257                 {
6258                   /* They also mark their opd section.  */
6259                   eh->elf.root.u.def.section->gc_mark = 1;
6260
6261                   rsec = fh->elf.root.u.def.section;
6262                 }
6263               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6264                        && opd_entry_value (eh->elf.root.u.def.section,
6265                                            eh->elf.root.u.def.value,
6266                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6267                 eh->elf.root.u.def.section->gc_mark = 1;
6268               else
6269                 rsec = h->root.u.def.section;
6270               break;
6271
6272             case bfd_link_hash_common:
6273               rsec = h->root.u.c.p->section;
6274               break;
6275
6276             default:
6277               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6278             }
6279         }
6280     }
6281   else
6282     {
6283       struct _opd_sec_data *opd;
6284
6285       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6286       opd = get_opd_info (rsec);
6287       if (opd != NULL && opd->func_sec != NULL)
6288         {
6289           rsec->gc_mark = 1;
6290
6291           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6292         }
6293     }
6294
6295   return rsec;
6296 }
6297
6298 /* Update the .got, .plt. and dynamic reloc reference counts for the
6299    section being removed.  */
6300
6301 static bfd_boolean
6302 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6303                          asection *sec, const Elf_Internal_Rela *relocs)
6304 {
6305   struct ppc_link_hash_table *htab;
6306   Elf_Internal_Shdr *symtab_hdr;
6307   struct elf_link_hash_entry **sym_hashes;
6308   struct got_entry **local_got_ents;
6309   const Elf_Internal_Rela *rel, *relend;
6310
6311   if (info->relocatable)
6312     return TRUE;
6313
6314   if ((sec->flags & SEC_ALLOC) == 0)
6315     return TRUE;
6316
6317   elf_section_data (sec)->local_dynrel = NULL;
6318
6319   htab = ppc_hash_table (info);
6320   if (htab == NULL)
6321     return FALSE;
6322
6323   symtab_hdr = &elf_symtab_hdr (abfd);
6324   sym_hashes = elf_sym_hashes (abfd);
6325   local_got_ents = elf_local_got_ents (abfd);
6326
6327   relend = relocs + sec->reloc_count;
6328   for (rel = relocs; rel < relend; rel++)
6329     {
6330       unsigned long r_symndx;
6331       enum elf_ppc64_reloc_type r_type;
6332       struct elf_link_hash_entry *h = NULL;
6333       unsigned char tls_type = 0;
6334
6335       r_symndx = ELF64_R_SYM (rel->r_info);
6336       r_type = ELF64_R_TYPE (rel->r_info);
6337       if (r_symndx >= symtab_hdr->sh_info)
6338         {
6339           struct ppc_link_hash_entry *eh;
6340           struct elf_dyn_relocs **pp;
6341           struct elf_dyn_relocs *p;
6342
6343           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6344           h = elf_follow_link (h);
6345           eh = (struct ppc_link_hash_entry *) h;
6346
6347           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6348             if (p->sec == sec)
6349               {
6350                 /* Everything must go for SEC.  */
6351                 *pp = p->next;
6352                 break;
6353               }
6354         }
6355
6356       if (is_branch_reloc (r_type))
6357         {
6358           struct plt_entry **ifunc = NULL;
6359           if (h != NULL)
6360             {
6361               if (h->type == STT_GNU_IFUNC)
6362                 ifunc = &h->plt.plist;
6363             }
6364           else if (local_got_ents != NULL)
6365             {
6366               struct plt_entry **local_plt = (struct plt_entry **)
6367                 (local_got_ents + symtab_hdr->sh_info);
6368               unsigned char *local_got_tls_masks = (unsigned char *)
6369                 (local_plt + symtab_hdr->sh_info);
6370               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6371                 ifunc = local_plt + r_symndx;
6372             }
6373           if (ifunc != NULL)
6374             {
6375               struct plt_entry *ent;
6376
6377               for (ent = *ifunc; ent != NULL; ent = ent->next)
6378                 if (ent->addend == rel->r_addend)
6379                   break;
6380               if (ent == NULL)
6381                 abort ();
6382               if (ent->plt.refcount > 0)
6383                 ent->plt.refcount -= 1;
6384               continue;
6385             }
6386         }
6387
6388       switch (r_type)
6389         {
6390         case R_PPC64_GOT_TLSLD16:
6391         case R_PPC64_GOT_TLSLD16_LO:
6392         case R_PPC64_GOT_TLSLD16_HI:
6393         case R_PPC64_GOT_TLSLD16_HA:
6394           tls_type = TLS_TLS | TLS_LD;
6395           goto dogot;
6396
6397         case R_PPC64_GOT_TLSGD16:
6398         case R_PPC64_GOT_TLSGD16_LO:
6399         case R_PPC64_GOT_TLSGD16_HI:
6400         case R_PPC64_GOT_TLSGD16_HA:
6401           tls_type = TLS_TLS | TLS_GD;
6402           goto dogot;
6403
6404         case R_PPC64_GOT_TPREL16_DS:
6405         case R_PPC64_GOT_TPREL16_LO_DS:
6406         case R_PPC64_GOT_TPREL16_HI:
6407         case R_PPC64_GOT_TPREL16_HA:
6408           tls_type = TLS_TLS | TLS_TPREL;
6409           goto dogot;
6410
6411         case R_PPC64_GOT_DTPREL16_DS:
6412         case R_PPC64_GOT_DTPREL16_LO_DS:
6413         case R_PPC64_GOT_DTPREL16_HI:
6414         case R_PPC64_GOT_DTPREL16_HA:
6415           tls_type = TLS_TLS | TLS_DTPREL;
6416           goto dogot;
6417
6418         case R_PPC64_GOT16:
6419         case R_PPC64_GOT16_DS:
6420         case R_PPC64_GOT16_HA:
6421         case R_PPC64_GOT16_HI:
6422         case R_PPC64_GOT16_LO:
6423         case R_PPC64_GOT16_LO_DS:
6424         dogot:
6425           {
6426             struct got_entry *ent;
6427
6428             if (h != NULL)
6429               ent = h->got.glist;
6430             else
6431               ent = local_got_ents[r_symndx];
6432
6433             for (; ent != NULL; ent = ent->next)
6434               if (ent->addend == rel->r_addend
6435                   && ent->owner == abfd
6436                   && ent->tls_type == tls_type)
6437                 break;
6438             if (ent == NULL)
6439               abort ();
6440             if (ent->got.refcount > 0)
6441               ent->got.refcount -= 1;
6442           }
6443           break;
6444
6445         case R_PPC64_PLT16_HA:
6446         case R_PPC64_PLT16_HI:
6447         case R_PPC64_PLT16_LO:
6448         case R_PPC64_PLT32:
6449         case R_PPC64_PLT64:
6450         case R_PPC64_REL14:
6451         case R_PPC64_REL14_BRNTAKEN:
6452         case R_PPC64_REL14_BRTAKEN:
6453         case R_PPC64_REL24:
6454           if (h != NULL)
6455             {
6456               struct plt_entry *ent;
6457
6458               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6459                 if (ent->addend == rel->r_addend)
6460                   break;
6461               if (ent != NULL && ent->plt.refcount > 0)
6462                 ent->plt.refcount -= 1;
6463             }
6464           break;
6465
6466         default:
6467           break;
6468         }
6469     }
6470   return TRUE;
6471 }
6472
6473 /* The maximum size of .sfpr.  */
6474 #define SFPR_MAX (218*4)
6475
6476 struct sfpr_def_parms
6477 {
6478   const char name[12];
6479   unsigned char lo, hi;
6480   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6481   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6482 };
6483
6484 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6485
6486 static bfd_boolean
6487 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6488 {
6489   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6490   unsigned int i;
6491   size_t len = strlen (parm->name);
6492   bfd_boolean writing = FALSE;
6493   char sym[16];
6494
6495   if (htab == NULL)
6496     return FALSE;
6497
6498   memcpy (sym, parm->name, len);
6499   sym[len + 2] = 0;
6500
6501   for (i = parm->lo; i <= parm->hi; i++)
6502     {
6503       struct elf_link_hash_entry *h;
6504
6505       sym[len + 0] = i / 10 + '0';
6506       sym[len + 1] = i % 10 + '0';
6507       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6508       if (h != NULL
6509           && !h->def_regular)
6510         {
6511           h->root.type = bfd_link_hash_defined;
6512           h->root.u.def.section = htab->sfpr;
6513           h->root.u.def.value = htab->sfpr->size;
6514           h->type = STT_FUNC;
6515           h->def_regular = 1;
6516           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6517           writing = TRUE;
6518           if (htab->sfpr->contents == NULL)
6519             {
6520               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6521               if (htab->sfpr->contents == NULL)
6522                 return FALSE;
6523             }
6524         }
6525       if (writing)
6526         {
6527           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6528           if (i != parm->hi)
6529             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6530           else
6531             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6532           htab->sfpr->size = p - htab->sfpr->contents;
6533         }
6534     }
6535
6536   return TRUE;
6537 }
6538
6539 static bfd_byte *
6540 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6541 {
6542   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6543   return p + 4;
6544 }
6545
6546 static bfd_byte *
6547 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6548 {
6549   p = savegpr0 (abfd, p, r);
6550   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6551   p = p + 4;
6552   bfd_put_32 (abfd, BLR, p);
6553   return p + 4;
6554 }
6555
6556 static bfd_byte *
6557 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6558 {
6559   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6560   return p + 4;
6561 }
6562
6563 static bfd_byte *
6564 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6565 {
6566   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6567   p = p + 4;
6568   p = restgpr0 (abfd, p, r);
6569   bfd_put_32 (abfd, MTLR_R0, p);
6570   p = p + 4;
6571   if (r == 29)
6572     {
6573       p = restgpr0 (abfd, p, 30);
6574       p = restgpr0 (abfd, p, 31);
6575     }
6576   bfd_put_32 (abfd, BLR, p);
6577   return p + 4;
6578 }
6579
6580 static bfd_byte *
6581 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6582 {
6583   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6584   return p + 4;
6585 }
6586
6587 static bfd_byte *
6588 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6589 {
6590   p = savegpr1 (abfd, p, r);
6591   bfd_put_32 (abfd, BLR, p);
6592   return p + 4;
6593 }
6594
6595 static bfd_byte *
6596 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6597 {
6598   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6599   return p + 4;
6600 }
6601
6602 static bfd_byte *
6603 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6604 {
6605   p = restgpr1 (abfd, p, r);
6606   bfd_put_32 (abfd, BLR, p);
6607   return p + 4;
6608 }
6609
6610 static bfd_byte *
6611 savefpr (bfd *abfd, bfd_byte *p, int r)
6612 {
6613   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6614   return p + 4;
6615 }
6616
6617 static bfd_byte *
6618 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6619 {
6620   p = savefpr (abfd, p, r);
6621   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6622   p = p + 4;
6623   bfd_put_32 (abfd, BLR, p);
6624   return p + 4;
6625 }
6626
6627 static bfd_byte *
6628 restfpr (bfd *abfd, bfd_byte *p, int r)
6629 {
6630   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6631   return p + 4;
6632 }
6633
6634 static bfd_byte *
6635 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6636 {
6637   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6638   p = p + 4;
6639   p = restfpr (abfd, p, r);
6640   bfd_put_32 (abfd, MTLR_R0, p);
6641   p = p + 4;
6642   if (r == 29)
6643     {
6644       p = restfpr (abfd, p, 30);
6645       p = restfpr (abfd, p, 31);
6646     }
6647   bfd_put_32 (abfd, BLR, p);
6648   return p + 4;
6649 }
6650
6651 static bfd_byte *
6652 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6653 {
6654   p = savefpr (abfd, p, r);
6655   bfd_put_32 (abfd, BLR, p);
6656   return p + 4;
6657 }
6658
6659 static bfd_byte *
6660 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6661 {
6662   p = restfpr (abfd, p, r);
6663   bfd_put_32 (abfd, BLR, p);
6664   return p + 4;
6665 }
6666
6667 static bfd_byte *
6668 savevr (bfd *abfd, bfd_byte *p, int r)
6669 {
6670   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6671   p = p + 4;
6672   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6673   return p + 4;
6674 }
6675
6676 static bfd_byte *
6677 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6678 {
6679   p = savevr (abfd, p, r);
6680   bfd_put_32 (abfd, BLR, p);
6681   return p + 4;
6682 }
6683
6684 static bfd_byte *
6685 restvr (bfd *abfd, bfd_byte *p, int r)
6686 {
6687   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6688   p = p + 4;
6689   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6690   return p + 4;
6691 }
6692
6693 static bfd_byte *
6694 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6695 {
6696   p = restvr (abfd, p, r);
6697   bfd_put_32 (abfd, BLR, p);
6698   return p + 4;
6699 }
6700
6701 /* Called via elf_link_hash_traverse to transfer dynamic linking
6702    information on function code symbol entries to their corresponding
6703    function descriptor symbol entries.  */
6704
6705 static bfd_boolean
6706 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6707 {
6708   struct bfd_link_info *info;
6709   struct ppc_link_hash_table *htab;
6710   struct plt_entry *ent;
6711   struct ppc_link_hash_entry *fh;
6712   struct ppc_link_hash_entry *fdh;
6713   bfd_boolean force_local;
6714
6715   fh = (struct ppc_link_hash_entry *) h;
6716   if (fh->elf.root.type == bfd_link_hash_indirect)
6717     return TRUE;
6718
6719   info = inf;
6720   htab = ppc_hash_table (info);
6721   if (htab == NULL)
6722     return FALSE;
6723
6724   /* Resolve undefined references to dot-symbols as the value
6725      in the function descriptor, if we have one in a regular object.
6726      This is to satisfy cases like ".quad .foo".  Calls to functions
6727      in dynamic objects are handled elsewhere.  */
6728   if (fh->elf.root.type == bfd_link_hash_undefweak
6729       && fh->was_undefined
6730       && (fdh = defined_func_desc (fh)) != NULL
6731       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6732       && opd_entry_value (fdh->elf.root.u.def.section,
6733                           fdh->elf.root.u.def.value,
6734                           &fh->elf.root.u.def.section,
6735                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6736     {
6737       fh->elf.root.type = fdh->elf.root.type;
6738       fh->elf.forced_local = 1;
6739       fh->elf.def_regular = fdh->elf.def_regular;
6740       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6741     }
6742
6743   /* If this is a function code symbol, transfer dynamic linking
6744      information to the function descriptor symbol.  */
6745   if (!fh->is_func)
6746     return TRUE;
6747
6748   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6749     if (ent->plt.refcount > 0)
6750       break;
6751   if (ent == NULL
6752       || fh->elf.root.root.string[0] != '.'
6753       || fh->elf.root.root.string[1] == '\0')
6754     return TRUE;
6755
6756   /* Find the corresponding function descriptor symbol.  Create it
6757      as undefined if necessary.  */
6758
6759   fdh = lookup_fdh (fh, htab);
6760   if (fdh == NULL
6761       && !info->executable
6762       && (fh->elf.root.type == bfd_link_hash_undefined
6763           || fh->elf.root.type == bfd_link_hash_undefweak))
6764     {
6765       fdh = make_fdh (info, fh);
6766       if (fdh == NULL)
6767         return FALSE;
6768     }
6769
6770   /* Fake function descriptors are made undefweak.  If the function
6771      code symbol is strong undefined, make the fake sym the same.
6772      If the function code symbol is defined, then force the fake
6773      descriptor local;  We can't support overriding of symbols in a
6774      shared library on a fake descriptor.  */
6775
6776   if (fdh != NULL
6777       && fdh->fake
6778       && fdh->elf.root.type == bfd_link_hash_undefweak)
6779     {
6780       if (fh->elf.root.type == bfd_link_hash_undefined)
6781         {
6782           fdh->elf.root.type = bfd_link_hash_undefined;
6783           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6784         }
6785       else if (fh->elf.root.type == bfd_link_hash_defined
6786                || fh->elf.root.type == bfd_link_hash_defweak)
6787         {
6788           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6789         }
6790     }
6791
6792   if (fdh != NULL
6793       && !fdh->elf.forced_local
6794       && (!info->executable
6795           || fdh->elf.def_dynamic
6796           || fdh->elf.ref_dynamic
6797           || (fdh->elf.root.type == bfd_link_hash_undefweak
6798               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6799     {
6800       if (fdh->elf.dynindx == -1)
6801         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6802           return FALSE;
6803       fdh->elf.ref_regular |= fh->elf.ref_regular;
6804       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6805       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6806       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6807       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6808         {
6809           move_plt_plist (fh, fdh);
6810           fdh->elf.needs_plt = 1;
6811         }
6812       fdh->is_func_descriptor = 1;
6813       fdh->oh = fh;
6814       fh->oh = fdh;
6815     }
6816
6817   /* Now that the info is on the function descriptor, clear the
6818      function code sym info.  Any function code syms for which we
6819      don't have a definition in a regular file, we force local.
6820      This prevents a shared library from exporting syms that have
6821      been imported from another library.  Function code syms that
6822      are really in the library we must leave global to prevent the
6823      linker dragging in a definition from a static library.  */
6824   force_local = (!fh->elf.def_regular
6825                  || fdh == NULL
6826                  || !fdh->elf.def_regular
6827                  || fdh->elf.forced_local);
6828   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6829
6830   return TRUE;
6831 }
6832
6833 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6834    this hook to a) provide some gcc support functions, and b) transfer
6835    dynamic linking information gathered so far on function code symbol
6836    entries, to their corresponding function descriptor symbol entries.  */
6837
6838 static bfd_boolean
6839 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6840                             struct bfd_link_info *info)
6841 {
6842   struct ppc_link_hash_table *htab;
6843   unsigned int i;
6844   static const struct sfpr_def_parms funcs[] =
6845     {
6846       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6847       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6848       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6849       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6850       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6851       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6852       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6853       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6854       { "._savef", 14, 31, savefpr, savefpr1_tail },
6855       { "._restf", 14, 31, restfpr, restfpr1_tail },
6856       { "_savevr_", 20, 31, savevr, savevr_tail },
6857       { "_restvr_", 20, 31, restvr, restvr_tail }
6858     };
6859
6860   htab = ppc_hash_table (info);
6861   if (htab == NULL)
6862     return FALSE;
6863
6864   if (!info->relocatable
6865       && htab->elf.hgot != NULL)
6866     {
6867       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6868       /* Make .TOC. defined so as to prevent it being made dynamic.
6869          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6870       htab->elf.hgot->type = STT_OBJECT;
6871       htab->elf.hgot->root.type = bfd_link_hash_defined;
6872       htab->elf.hgot->root.u.def.value = 0;
6873       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6874       htab->elf.hgot->def_regular = 1;
6875       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6876                                | STV_HIDDEN);
6877     }
6878
6879   if (htab->sfpr == NULL)
6880     /* We don't have any relocs.  */
6881     return TRUE;
6882
6883   /* Provide any missing _save* and _rest* functions.  */
6884   htab->sfpr->size = 0;
6885   if (htab->params->save_restore_funcs)
6886     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6887       if (!sfpr_define (info, &funcs[i]))
6888         return FALSE;
6889
6890   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6891
6892   if (htab->sfpr->size == 0)
6893     htab->sfpr->flags |= SEC_EXCLUDE;
6894
6895   return TRUE;
6896 }
6897
6898 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6899
6900 static bfd_boolean
6901 readonly_dynrelocs (struct elf_link_hash_entry *h)
6902 {
6903   struct ppc_link_hash_entry *eh;
6904   struct elf_dyn_relocs *p;
6905
6906   eh = (struct ppc_link_hash_entry *) h;
6907   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6908     {
6909       asection *s = p->sec->output_section;
6910
6911       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6912         return TRUE;
6913     }
6914   return FALSE;
6915 }
6916
6917 /* Adjust a symbol defined by a dynamic object and referenced by a
6918    regular object.  The current definition is in some section of the
6919    dynamic object, but we're not including those sections.  We have to
6920    change the definition to something the rest of the link can
6921    understand.  */
6922
6923 static bfd_boolean
6924 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6925                                  struct elf_link_hash_entry *h)
6926 {
6927   struct ppc_link_hash_table *htab;
6928   asection *s;
6929
6930   htab = ppc_hash_table (info);
6931   if (htab == NULL)
6932     return FALSE;
6933
6934   /* Deal with function syms.  */
6935   if (h->type == STT_FUNC
6936       || h->type == STT_GNU_IFUNC
6937       || h->needs_plt)
6938     {
6939       /* Clear procedure linkage table information for any symbol that
6940          won't need a .plt entry.  */
6941       struct plt_entry *ent;
6942       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6943         if (ent->plt.refcount > 0)
6944           break;
6945       if (ent == NULL
6946           || (h->type != STT_GNU_IFUNC
6947               && (SYMBOL_CALLS_LOCAL (info, h)
6948                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6949                       && h->root.type == bfd_link_hash_undefweak))))
6950         {
6951           h->plt.plist = NULL;
6952           h->needs_plt = 0;
6953         }
6954       else if (abiversion (info->output_bfd) == 2)
6955         {
6956           /* After adjust_dynamic_symbol, non_got_ref set in the
6957              non-shared case means that we have allocated space in
6958              .dynbss for the symbol and thus dyn_relocs for this
6959              symbol should be discarded.
6960              If we get here we know we are making a PLT entry for this
6961              symbol, and in an executable we'd normally resolve
6962              relocations against this symbol to the PLT entry.  Allow
6963              dynamic relocs if the reference is weak, and the dynamic
6964              relocs will not cause text relocation.  */
6965           if (!h->ref_regular_nonweak
6966               && h->non_got_ref
6967               && h->type != STT_GNU_IFUNC
6968               && !readonly_dynrelocs (h))
6969             h->non_got_ref = 0;
6970
6971           /* If making a plt entry, then we don't need copy relocs.  */
6972           return TRUE;
6973         }
6974     }
6975   else
6976     h->plt.plist = NULL;
6977
6978   /* If this is a weak symbol, and there is a real definition, the
6979      processor independent code will have arranged for us to see the
6980      real definition first, and we can just use the same value.  */
6981   if (h->u.weakdef != NULL)
6982     {
6983       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6984                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6985       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6986       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6987       if (ELIMINATE_COPY_RELOCS)
6988         h->non_got_ref = h->u.weakdef->non_got_ref;
6989       return TRUE;
6990     }
6991
6992   /* If we are creating a shared library, we must presume that the
6993      only references to the symbol are via the global offset table.
6994      For such cases we need not do anything here; the relocations will
6995      be handled correctly by relocate_section.  */
6996   if (info->shared)
6997     return TRUE;
6998
6999   /* If there are no references to this symbol that do not use the
7000      GOT, we don't need to generate a copy reloc.  */
7001   if (!h->non_got_ref)
7002     return TRUE;
7003
7004   /* Don't generate a copy reloc for symbols defined in the executable.  */
7005   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7006     return TRUE;
7007
7008   /* If we didn't find any dynamic relocs in read-only sections, then
7009      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7010   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7011     {
7012       h->non_got_ref = 0;
7013       return TRUE;
7014     }
7015
7016   if (h->plt.plist != NULL)
7017     {
7018       /* We should never get here, but unfortunately there are versions
7019          of gcc out there that improperly (for this ABI) put initialized
7020          function pointers, vtable refs and suchlike in read-only
7021          sections.  Allow them to proceed, but warn that this might
7022          break at runtime.  */
7023       info->callbacks->einfo
7024         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7025            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7026          h->root.root.string);
7027     }
7028
7029   /* This is a reference to a symbol defined by a dynamic object which
7030      is not a function.  */
7031
7032   /* We must allocate the symbol in our .dynbss section, which will
7033      become part of the .bss section of the executable.  There will be
7034      an entry for this symbol in the .dynsym section.  The dynamic
7035      object will contain position independent code, so all references
7036      from the dynamic object to this symbol will go through the global
7037      offset table.  The dynamic linker will use the .dynsym entry to
7038      determine the address it must put in the global offset table, so
7039      both the dynamic object and the regular object will refer to the
7040      same memory location for the variable.  */
7041
7042   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7043      to copy the initial value out of the dynamic object and into the
7044      runtime process image.  We need to remember the offset into the
7045      .rela.bss section we are going to use.  */
7046   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7047     {
7048       htab->relbss->size += sizeof (Elf64_External_Rela);
7049       h->needs_copy = 1;
7050     }
7051
7052   s = htab->dynbss;
7053
7054   return _bfd_elf_adjust_dynamic_copy (h, s);
7055 }
7056
7057 /* If given a function descriptor symbol, hide both the function code
7058    sym and the descriptor.  */
7059 static void
7060 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7061                        struct elf_link_hash_entry *h,
7062                        bfd_boolean force_local)
7063 {
7064   struct ppc_link_hash_entry *eh;
7065   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7066
7067   eh = (struct ppc_link_hash_entry *) h;
7068   if (eh->is_func_descriptor)
7069     {
7070       struct ppc_link_hash_entry *fh = eh->oh;
7071
7072       if (fh == NULL)
7073         {
7074           const char *p, *q;
7075           struct ppc_link_hash_table *htab;
7076           char save;
7077
7078           /* We aren't supposed to use alloca in BFD because on
7079              systems which do not have alloca the version in libiberty
7080              calls xmalloc, which might cause the program to crash
7081              when it runs out of memory.  This function doesn't have a
7082              return status, so there's no way to gracefully return an
7083              error.  So cheat.  We know that string[-1] can be safely
7084              accessed;  It's either a string in an ELF string table,
7085              or allocated in an objalloc structure.  */
7086
7087           p = eh->elf.root.root.string - 1;
7088           save = *p;
7089           *(char *) p = '.';
7090           htab = ppc_hash_table (info);
7091           if (htab == NULL)
7092             return;
7093
7094           fh = (struct ppc_link_hash_entry *)
7095             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7096           *(char *) p = save;
7097
7098           /* Unfortunately, if it so happens that the string we were
7099              looking for was allocated immediately before this string,
7100              then we overwrote the string terminator.  That's the only
7101              reason the lookup should fail.  */
7102           if (fh == NULL)
7103             {
7104               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7105               while (q >= eh->elf.root.root.string && *q == *p)
7106                 --q, --p;
7107               if (q < eh->elf.root.root.string && *p == '.')
7108                 fh = (struct ppc_link_hash_entry *)
7109                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7110             }
7111           if (fh != NULL)
7112             {
7113               eh->oh = fh;
7114               fh->oh = eh;
7115             }
7116         }
7117       if (fh != NULL)
7118         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7119     }
7120 }
7121
7122 static bfd_boolean
7123 get_sym_h (struct elf_link_hash_entry **hp,
7124            Elf_Internal_Sym **symp,
7125            asection **symsecp,
7126            unsigned char **tls_maskp,
7127            Elf_Internal_Sym **locsymsp,
7128            unsigned long r_symndx,
7129            bfd *ibfd)
7130 {
7131   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7132
7133   if (r_symndx >= symtab_hdr->sh_info)
7134     {
7135       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7136       struct elf_link_hash_entry *h;
7137
7138       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7139       h = elf_follow_link (h);
7140
7141       if (hp != NULL)
7142         *hp = h;
7143
7144       if (symp != NULL)
7145         *symp = NULL;
7146
7147       if (symsecp != NULL)
7148         {
7149           asection *symsec = NULL;
7150           if (h->root.type == bfd_link_hash_defined
7151               || h->root.type == bfd_link_hash_defweak)
7152             symsec = h->root.u.def.section;
7153           *symsecp = symsec;
7154         }
7155
7156       if (tls_maskp != NULL)
7157         {
7158           struct ppc_link_hash_entry *eh;
7159
7160           eh = (struct ppc_link_hash_entry *) h;
7161           *tls_maskp = &eh->tls_mask;
7162         }
7163     }
7164   else
7165     {
7166       Elf_Internal_Sym *sym;
7167       Elf_Internal_Sym *locsyms = *locsymsp;
7168
7169       if (locsyms == NULL)
7170         {
7171           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7172           if (locsyms == NULL)
7173             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7174                                             symtab_hdr->sh_info,
7175                                             0, NULL, NULL, NULL);
7176           if (locsyms == NULL)
7177             return FALSE;
7178           *locsymsp = locsyms;
7179         }
7180       sym = locsyms + r_symndx;
7181
7182       if (hp != NULL)
7183         *hp = NULL;
7184
7185       if (symp != NULL)
7186         *symp = sym;
7187
7188       if (symsecp != NULL)
7189         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7190
7191       if (tls_maskp != NULL)
7192         {
7193           struct got_entry **lgot_ents;
7194           unsigned char *tls_mask;
7195
7196           tls_mask = NULL;
7197           lgot_ents = elf_local_got_ents (ibfd);
7198           if (lgot_ents != NULL)
7199             {
7200               struct plt_entry **local_plt = (struct plt_entry **)
7201                 (lgot_ents + symtab_hdr->sh_info);
7202               unsigned char *lgot_masks = (unsigned char *)
7203                 (local_plt + symtab_hdr->sh_info);
7204               tls_mask = &lgot_masks[r_symndx];
7205             }
7206           *tls_maskp = tls_mask;
7207         }
7208     }
7209   return TRUE;
7210 }
7211
7212 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7213    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7214    type suitable for optimization, and 1 otherwise.  */
7215
7216 static int
7217 get_tls_mask (unsigned char **tls_maskp,
7218               unsigned long *toc_symndx,
7219               bfd_vma *toc_addend,
7220               Elf_Internal_Sym **locsymsp,
7221               const Elf_Internal_Rela *rel,
7222               bfd *ibfd)
7223 {
7224   unsigned long r_symndx;
7225   int next_r;
7226   struct elf_link_hash_entry *h;
7227   Elf_Internal_Sym *sym;
7228   asection *sec;
7229   bfd_vma off;
7230
7231   r_symndx = ELF64_R_SYM (rel->r_info);
7232   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7233     return 0;
7234
7235   if ((*tls_maskp != NULL && **tls_maskp != 0)
7236       || sec == NULL
7237       || ppc64_elf_section_data (sec) == NULL
7238       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7239     return 1;
7240
7241   /* Look inside a TOC section too.  */
7242   if (h != NULL)
7243     {
7244       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7245       off = h->root.u.def.value;
7246     }
7247   else
7248     off = sym->st_value;
7249   off += rel->r_addend;
7250   BFD_ASSERT (off % 8 == 0);
7251   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7252   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7253   if (toc_symndx != NULL)
7254     *toc_symndx = r_symndx;
7255   if (toc_addend != NULL)
7256     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7257   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7258     return 0;
7259   if ((h == NULL || is_static_defined (h))
7260       && (next_r == -1 || next_r == -2))
7261     return 1 - next_r;
7262   return 1;
7263 }
7264
7265 /* Find (or create) an entry in the tocsave hash table.  */
7266
7267 static struct tocsave_entry *
7268 tocsave_find (struct ppc_link_hash_table *htab,
7269               enum insert_option insert,
7270               Elf_Internal_Sym **local_syms,
7271               const Elf_Internal_Rela *irela,
7272               bfd *ibfd)
7273 {
7274   unsigned long r_indx;
7275   struct elf_link_hash_entry *h;
7276   Elf_Internal_Sym *sym;
7277   struct tocsave_entry ent, *p;
7278   hashval_t hash;
7279   struct tocsave_entry **slot;
7280
7281   r_indx = ELF64_R_SYM (irela->r_info);
7282   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7283     return NULL;
7284   if (ent.sec == NULL || ent.sec->output_section == NULL)
7285     {
7286       (*_bfd_error_handler)
7287         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7288       return NULL;
7289     }
7290
7291   if (h != NULL)
7292     ent.offset = h->root.u.def.value;
7293   else
7294     ent.offset = sym->st_value;
7295   ent.offset += irela->r_addend;
7296
7297   hash = tocsave_htab_hash (&ent);
7298   slot = ((struct tocsave_entry **)
7299           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7300   if (slot == NULL)
7301     return NULL;
7302
7303   if (*slot == NULL)
7304     {
7305       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7306       if (p == NULL)
7307         return NULL;
7308       *p = ent;
7309       *slot = p;
7310     }
7311   return *slot;
7312 }
7313
7314 /* Adjust all global syms defined in opd sections.  In gcc generated
7315    code for the old ABI, these will already have been done.  */
7316
7317 static bfd_boolean
7318 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7319 {
7320   struct ppc_link_hash_entry *eh;
7321   asection *sym_sec;
7322   struct _opd_sec_data *opd;
7323
7324   if (h->root.type == bfd_link_hash_indirect)
7325     return TRUE;
7326
7327   if (h->root.type != bfd_link_hash_defined
7328       && h->root.type != bfd_link_hash_defweak)
7329     return TRUE;
7330
7331   eh = (struct ppc_link_hash_entry *) h;
7332   if (eh->adjust_done)
7333     return TRUE;
7334
7335   sym_sec = eh->elf.root.u.def.section;
7336   opd = get_opd_info (sym_sec);
7337   if (opd != NULL && opd->adjust != NULL)
7338     {
7339       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7340       if (adjust == -1)
7341         {
7342           /* This entry has been deleted.  */
7343           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7344           if (dsec == NULL)
7345             {
7346               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7347                 if (discarded_section (dsec))
7348                   {
7349                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7350                     break;
7351                   }
7352             }
7353           eh->elf.root.u.def.value = 0;
7354           eh->elf.root.u.def.section = dsec;
7355         }
7356       else
7357         eh->elf.root.u.def.value += adjust;
7358       eh->adjust_done = 1;
7359     }
7360   return TRUE;
7361 }
7362
7363 /* Handles decrementing dynamic reloc counts for the reloc specified by
7364    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7365    have already been determined.  */
7366
7367 static bfd_boolean
7368 dec_dynrel_count (bfd_vma r_info,
7369                   asection *sec,
7370                   struct bfd_link_info *info,
7371                   Elf_Internal_Sym **local_syms,
7372                   struct elf_link_hash_entry *h,
7373                   Elf_Internal_Sym *sym)
7374 {
7375   enum elf_ppc64_reloc_type r_type;
7376   asection *sym_sec = NULL;
7377
7378   /* Can this reloc be dynamic?  This switch, and later tests here
7379      should be kept in sync with the code in check_relocs.  */
7380   r_type = ELF64_R_TYPE (r_info);
7381   switch (r_type)
7382     {
7383     default:
7384       return TRUE;
7385
7386     case R_PPC64_TPREL16:
7387     case R_PPC64_TPREL16_LO:
7388     case R_PPC64_TPREL16_HI:
7389     case R_PPC64_TPREL16_HA:
7390     case R_PPC64_TPREL16_DS:
7391     case R_PPC64_TPREL16_LO_DS:
7392     case R_PPC64_TPREL16_HIGH:
7393     case R_PPC64_TPREL16_HIGHA:
7394     case R_PPC64_TPREL16_HIGHER:
7395     case R_PPC64_TPREL16_HIGHERA:
7396     case R_PPC64_TPREL16_HIGHEST:
7397     case R_PPC64_TPREL16_HIGHESTA:
7398       if (!info->shared)
7399         return TRUE;
7400
7401     case R_PPC64_TPREL64:
7402     case R_PPC64_DTPMOD64:
7403     case R_PPC64_DTPREL64:
7404     case R_PPC64_ADDR64:
7405     case R_PPC64_REL30:
7406     case R_PPC64_REL32:
7407     case R_PPC64_REL64:
7408     case R_PPC64_ADDR14:
7409     case R_PPC64_ADDR14_BRNTAKEN:
7410     case R_PPC64_ADDR14_BRTAKEN:
7411     case R_PPC64_ADDR16:
7412     case R_PPC64_ADDR16_DS:
7413     case R_PPC64_ADDR16_HA:
7414     case R_PPC64_ADDR16_HI:
7415     case R_PPC64_ADDR16_HIGH:
7416     case R_PPC64_ADDR16_HIGHA:
7417     case R_PPC64_ADDR16_HIGHER:
7418     case R_PPC64_ADDR16_HIGHERA:
7419     case R_PPC64_ADDR16_HIGHEST:
7420     case R_PPC64_ADDR16_HIGHESTA:
7421     case R_PPC64_ADDR16_LO:
7422     case R_PPC64_ADDR16_LO_DS:
7423     case R_PPC64_ADDR24:
7424     case R_PPC64_ADDR32:
7425     case R_PPC64_UADDR16:
7426     case R_PPC64_UADDR32:
7427     case R_PPC64_UADDR64:
7428     case R_PPC64_TOC:
7429       break;
7430     }
7431
7432   if (local_syms != NULL)
7433     {
7434       unsigned long r_symndx;
7435       bfd *ibfd = sec->owner;
7436
7437       r_symndx = ELF64_R_SYM (r_info);
7438       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7439         return FALSE;
7440     }
7441
7442   if ((info->shared
7443        && (must_be_dyn_reloc (info, r_type)
7444            || (h != NULL
7445                && (!SYMBOLIC_BIND (info, h)
7446                    || h->root.type == bfd_link_hash_defweak
7447                    || !h->def_regular))))
7448       || (ELIMINATE_COPY_RELOCS
7449           && !info->shared
7450           && h != NULL
7451           && (h->root.type == bfd_link_hash_defweak
7452               || !h->def_regular)))
7453     ;
7454   else
7455     return TRUE;
7456
7457   if (h != NULL)
7458     {
7459       struct elf_dyn_relocs *p;
7460       struct elf_dyn_relocs **pp;
7461       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7462
7463       /* elf_gc_sweep may have already removed all dyn relocs associated
7464          with local syms for a given section.  Also, symbol flags are
7465          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7466          report a dynreloc miscount.  */
7467       if (*pp == NULL && info->gc_sections)
7468         return TRUE;
7469
7470       while ((p = *pp) != NULL)
7471         {
7472           if (p->sec == sec)
7473             {
7474               if (!must_be_dyn_reloc (info, r_type))
7475                 p->pc_count -= 1;
7476               p->count -= 1;
7477               if (p->count == 0)
7478                 *pp = p->next;
7479               return TRUE;
7480             }
7481           pp = &p->next;
7482         }
7483     }
7484   else
7485     {
7486       struct ppc_dyn_relocs *p;
7487       struct ppc_dyn_relocs **pp;
7488       void *vpp;
7489       bfd_boolean is_ifunc;
7490
7491       if (local_syms == NULL)
7492         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7493       if (sym_sec == NULL)
7494         sym_sec = sec;
7495
7496       vpp = &elf_section_data (sym_sec)->local_dynrel;
7497       pp = (struct ppc_dyn_relocs **) vpp;
7498
7499       if (*pp == NULL && info->gc_sections)
7500         return TRUE;
7501
7502       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7503       while ((p = *pp) != NULL)
7504         {
7505           if (p->sec == sec && p->ifunc == is_ifunc)
7506             {
7507               p->count -= 1;
7508               if (p->count == 0)
7509                 *pp = p->next;
7510               return TRUE;
7511             }
7512           pp = &p->next;
7513         }
7514     }
7515
7516   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7517                           sec->owner, sec);
7518   bfd_set_error (bfd_error_bad_value);
7519   return FALSE;
7520 }
7521
7522 /* Remove unused Official Procedure Descriptor entries.  Currently we
7523    only remove those associated with functions in discarded link-once
7524    sections, or weakly defined functions that have been overridden.  It
7525    would be possible to remove many more entries for statically linked
7526    applications.  */
7527
7528 bfd_boolean
7529 ppc64_elf_edit_opd (struct bfd_link_info *info)
7530 {
7531   bfd *ibfd;
7532   bfd_boolean some_edited = FALSE;
7533   asection *need_pad = NULL;
7534   struct ppc_link_hash_table *htab;
7535
7536   htab = ppc_hash_table (info);
7537   if (htab == NULL)
7538     return FALSE;
7539
7540   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7541     {
7542       asection *sec;
7543       Elf_Internal_Rela *relstart, *rel, *relend;
7544       Elf_Internal_Shdr *symtab_hdr;
7545       Elf_Internal_Sym *local_syms;
7546       bfd_vma offset;
7547       struct _opd_sec_data *opd;
7548       bfd_boolean need_edit, add_aux_fields;
7549       bfd_size_type cnt_16b = 0;
7550
7551       if (!is_ppc64_elf (ibfd))
7552         continue;
7553
7554       sec = bfd_get_section_by_name (ibfd, ".opd");
7555       if (sec == NULL || sec->size == 0)
7556         continue;
7557
7558       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7559         continue;
7560
7561       if (sec->output_section == bfd_abs_section_ptr)
7562         continue;
7563
7564       /* Look through the section relocs.  */
7565       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7566         continue;
7567
7568       local_syms = NULL;
7569       symtab_hdr = &elf_symtab_hdr (ibfd);
7570
7571       /* Read the relocations.  */
7572       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7573                                             info->keep_memory);
7574       if (relstart == NULL)
7575         return FALSE;
7576
7577       /* First run through the relocs to check they are sane, and to
7578          determine whether we need to edit this opd section.  */
7579       need_edit = FALSE;
7580       need_pad = sec;
7581       offset = 0;
7582       relend = relstart + sec->reloc_count;
7583       for (rel = relstart; rel < relend; )
7584         {
7585           enum elf_ppc64_reloc_type r_type;
7586           unsigned long r_symndx;
7587           asection *sym_sec;
7588           struct elf_link_hash_entry *h;
7589           Elf_Internal_Sym *sym;
7590
7591           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7592              only interested in the reloc pointing to a function entry
7593              point.  */
7594           if (rel->r_offset != offset
7595               || rel + 1 >= relend
7596               || (rel + 1)->r_offset != offset + 8)
7597             {
7598               /* If someone messes with .opd alignment then after a
7599                  "ld -r" we might have padding in the middle of .opd.
7600                  Also, there's nothing to prevent someone putting
7601                  something silly in .opd with the assembler.  No .opd
7602                  optimization for them!  */
7603             broken_opd:
7604               (*_bfd_error_handler)
7605                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7606               need_edit = FALSE;
7607               break;
7608             }
7609
7610           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7611               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7612             {
7613               (*_bfd_error_handler)
7614                 (_("%B: unexpected reloc type %u in .opd section"),
7615                  ibfd, r_type);
7616               need_edit = FALSE;
7617               break;
7618             }
7619
7620           r_symndx = ELF64_R_SYM (rel->r_info);
7621           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7622                           r_symndx, ibfd))
7623             goto error_ret;
7624
7625           if (sym_sec == NULL || sym_sec->owner == NULL)
7626             {
7627               const char *sym_name;
7628               if (h != NULL)
7629                 sym_name = h->root.root.string;
7630               else
7631                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7632                                              sym_sec);
7633
7634               (*_bfd_error_handler)
7635                 (_("%B: undefined sym `%s' in .opd section"),
7636                  ibfd, sym_name);
7637               need_edit = FALSE;
7638               break;
7639             }
7640
7641           /* opd entries are always for functions defined in the
7642              current input bfd.  If the symbol isn't defined in the
7643              input bfd, then we won't be using the function in this
7644              bfd;  It must be defined in a linkonce section in another
7645              bfd, or is weak.  It's also possible that we are
7646              discarding the function due to a linker script /DISCARD/,
7647              which we test for via the output_section.  */
7648           if (sym_sec->owner != ibfd
7649               || sym_sec->output_section == bfd_abs_section_ptr)
7650             need_edit = TRUE;
7651
7652           rel += 2;
7653           if (rel == relend
7654               || (rel + 1 == relend && rel->r_offset == offset + 16))
7655             {
7656               if (sec->size == offset + 24)
7657                 {
7658                   need_pad = NULL;
7659                   break;
7660                 }
7661               if (rel == relend && sec->size == offset + 16)
7662                 {
7663                   cnt_16b++;
7664                   break;
7665                 }
7666               goto broken_opd;
7667             }
7668
7669           if (rel->r_offset == offset + 24)
7670             offset += 24;
7671           else if (rel->r_offset != offset + 16)
7672             goto broken_opd;
7673           else if (rel + 1 < relend
7674                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7675                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7676             {
7677               offset += 16;
7678               cnt_16b++;
7679             }
7680           else if (rel + 2 < relend
7681                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7682                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7683             {
7684               offset += 24;
7685               rel += 1;
7686             }
7687           else
7688             goto broken_opd;
7689         }
7690
7691       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7692
7693       if (need_edit || add_aux_fields)
7694         {
7695           Elf_Internal_Rela *write_rel;
7696           Elf_Internal_Shdr *rel_hdr;
7697           bfd_byte *rptr, *wptr;
7698           bfd_byte *new_contents;
7699           bfd_boolean skip;
7700           long opd_ent_size;
7701           bfd_size_type amt;
7702
7703           new_contents = NULL;
7704           amt = sec->size * sizeof (long) / 8;
7705           opd = &ppc64_elf_section_data (sec)->u.opd;
7706           opd->adjust = bfd_zalloc (sec->owner, amt);
7707           if (opd->adjust == NULL)
7708             return FALSE;
7709           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7710
7711           /* This seems a waste of time as input .opd sections are all
7712              zeros as generated by gcc, but I suppose there's no reason
7713              this will always be so.  We might start putting something in
7714              the third word of .opd entries.  */
7715           if ((sec->flags & SEC_IN_MEMORY) == 0)
7716             {
7717               bfd_byte *loc;
7718               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7719                 {
7720                   if (loc != NULL)
7721                     free (loc);
7722                 error_ret:
7723                   if (local_syms != NULL
7724                       && symtab_hdr->contents != (unsigned char *) local_syms)
7725                     free (local_syms);
7726                   if (elf_section_data (sec)->relocs != relstart)
7727                     free (relstart);
7728                   return FALSE;
7729                 }
7730               sec->contents = loc;
7731               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7732             }
7733
7734           elf_section_data (sec)->relocs = relstart;
7735
7736           new_contents = sec->contents;
7737           if (add_aux_fields)
7738             {
7739               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7740               if (new_contents == NULL)
7741                 return FALSE;
7742               need_pad = FALSE;
7743             }
7744           wptr = new_contents;
7745           rptr = sec->contents;
7746
7747           write_rel = relstart;
7748           skip = FALSE;
7749           offset = 0;
7750           opd_ent_size = 0;
7751           for (rel = relstart; rel < relend; rel++)
7752             {
7753               unsigned long r_symndx;
7754               asection *sym_sec;
7755               struct elf_link_hash_entry *h;
7756               Elf_Internal_Sym *sym;
7757
7758               r_symndx = ELF64_R_SYM (rel->r_info);
7759               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7760                               r_symndx, ibfd))
7761                 goto error_ret;
7762
7763               if (rel->r_offset == offset)
7764                 {
7765                   struct ppc_link_hash_entry *fdh = NULL;
7766
7767                   /* See if the .opd entry is full 24 byte or
7768                      16 byte (with fd_aux entry overlapped with next
7769                      fd_func).  */
7770                   opd_ent_size = 24;
7771                   if ((rel + 2 == relend && sec->size == offset + 16)
7772                       || (rel + 3 < relend
7773                           && rel[2].r_offset == offset + 16
7774                           && rel[3].r_offset == offset + 24
7775                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7776                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7777                     opd_ent_size = 16;
7778
7779                   if (h != NULL
7780                       && h->root.root.string[0] == '.')
7781                     {
7782                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7783                       if (fdh != NULL
7784                           && fdh->elf.root.type != bfd_link_hash_defined
7785                           && fdh->elf.root.type != bfd_link_hash_defweak)
7786                         fdh = NULL;
7787                     }
7788
7789                   skip = (sym_sec->owner != ibfd
7790                           || sym_sec->output_section == bfd_abs_section_ptr);
7791                   if (skip)
7792                     {
7793                       if (fdh != NULL && sym_sec->owner == ibfd)
7794                         {
7795                           /* Arrange for the function descriptor sym
7796                              to be dropped.  */
7797                           fdh->elf.root.u.def.value = 0;
7798                           fdh->elf.root.u.def.section = sym_sec;
7799                         }
7800                       opd->adjust[rel->r_offset / 8] = -1;
7801                     }
7802                   else
7803                     {
7804                       /* We'll be keeping this opd entry.  */
7805
7806                       if (fdh != NULL)
7807                         {
7808                           /* Redefine the function descriptor symbol to
7809                              this location in the opd section.  It is
7810                              necessary to update the value here rather
7811                              than using an array of adjustments as we do
7812                              for local symbols, because various places
7813                              in the generic ELF code use the value
7814                              stored in u.def.value.  */
7815                           fdh->elf.root.u.def.value = wptr - new_contents;
7816                           fdh->adjust_done = 1;
7817                         }
7818
7819                       /* Local syms are a bit tricky.  We could
7820                          tweak them as they can be cached, but
7821                          we'd need to look through the local syms
7822                          for the function descriptor sym which we
7823                          don't have at the moment.  So keep an
7824                          array of adjustments.  */
7825                       opd->adjust[rel->r_offset / 8]
7826                         = (wptr - new_contents) - (rptr - sec->contents);
7827
7828                       if (wptr != rptr)
7829                         memcpy (wptr, rptr, opd_ent_size);
7830                       wptr += opd_ent_size;
7831                       if (add_aux_fields && opd_ent_size == 16)
7832                         {
7833                           memset (wptr, '\0', 8);
7834                           wptr += 8;
7835                         }
7836                     }
7837                   rptr += opd_ent_size;
7838                   offset += opd_ent_size;
7839                 }
7840
7841               if (skip)
7842                 {
7843                   if (!NO_OPD_RELOCS
7844                       && !info->relocatable
7845                       && !dec_dynrel_count (rel->r_info, sec, info,
7846                                             NULL, h, sym))
7847                     goto error_ret;
7848                 }
7849               else
7850                 {
7851                   /* We need to adjust any reloc offsets to point to the
7852                      new opd entries.  While we're at it, we may as well
7853                      remove redundant relocs.  */
7854                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7855                   if (write_rel != rel)
7856                     memcpy (write_rel, rel, sizeof (*rel));
7857                   ++write_rel;
7858                 }
7859             }
7860
7861           sec->size = wptr - new_contents;
7862           sec->reloc_count = write_rel - relstart;
7863           if (add_aux_fields)
7864             {
7865               free (sec->contents);
7866               sec->contents = new_contents;
7867             }
7868
7869           /* Fudge the header size too, as this is used later in
7870              elf_bfd_final_link if we are emitting relocs.  */
7871           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7872           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7873           some_edited = TRUE;
7874         }
7875       else if (elf_section_data (sec)->relocs != relstart)
7876         free (relstart);
7877
7878       if (local_syms != NULL
7879           && symtab_hdr->contents != (unsigned char *) local_syms)
7880         {
7881           if (!info->keep_memory)
7882             free (local_syms);
7883           else
7884             symtab_hdr->contents = (unsigned char *) local_syms;
7885         }
7886     }
7887
7888   if (some_edited)
7889     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7890
7891   /* If we are doing a final link and the last .opd entry is just 16 byte
7892      long, add a 8 byte padding after it.  */
7893   if (need_pad != NULL && !info->relocatable)
7894     {
7895       bfd_byte *p;
7896
7897       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7898         {
7899           BFD_ASSERT (need_pad->size > 0);
7900
7901           p = bfd_malloc (need_pad->size + 8);
7902           if (p == NULL)
7903             return FALSE;
7904
7905           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7906                                           p, 0, need_pad->size))
7907             return FALSE;
7908
7909           need_pad->contents = p;
7910           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7911         }
7912       else
7913         {
7914           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7915           if (p == NULL)
7916             return FALSE;
7917
7918           need_pad->contents = p;
7919         }
7920
7921       memset (need_pad->contents + need_pad->size, 0, 8);
7922       need_pad->size += 8;
7923     }
7924
7925   return TRUE;
7926 }
7927
7928 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7929
7930 asection *
7931 ppc64_elf_tls_setup (struct bfd_link_info *info)
7932 {
7933   struct ppc_link_hash_table *htab;
7934
7935   htab = ppc_hash_table (info);
7936   if (htab == NULL)
7937     return NULL;
7938
7939   if (abiversion (info->output_bfd) == 1)
7940     htab->opd_abi = 1;
7941
7942   if (htab->params->no_multi_toc)
7943     htab->do_multi_toc = 0;
7944   else if (!htab->do_multi_toc)
7945     htab->params->no_multi_toc = 1;
7946
7947   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7948                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7949                                               FALSE, FALSE, TRUE));
7950   /* Move dynamic linking info to the function descriptor sym.  */
7951   if (htab->tls_get_addr != NULL)
7952     func_desc_adjust (&htab->tls_get_addr->elf, info);
7953   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7954                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7955                                                  FALSE, FALSE, TRUE));
7956   if (!htab->params->no_tls_get_addr_opt)
7957     {
7958       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7959
7960       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7961                                   FALSE, FALSE, TRUE);
7962       if (opt != NULL)
7963         func_desc_adjust (opt, info);
7964       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7965                                      FALSE, FALSE, TRUE);
7966       if (opt_fd != NULL
7967           && (opt_fd->root.type == bfd_link_hash_defined
7968               || opt_fd->root.type == bfd_link_hash_defweak))
7969         {
7970           /* If glibc supports an optimized __tls_get_addr call stub,
7971              signalled by the presence of __tls_get_addr_opt, and we'll
7972              be calling __tls_get_addr via a plt call stub, then
7973              make __tls_get_addr point to __tls_get_addr_opt.  */
7974           tga_fd = &htab->tls_get_addr_fd->elf;
7975           if (htab->elf.dynamic_sections_created
7976               && tga_fd != NULL
7977               && (tga_fd->type == STT_FUNC
7978                   || tga_fd->needs_plt)
7979               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7980                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7981                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7982             {
7983               struct plt_entry *ent;
7984
7985               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7986                 if (ent->plt.refcount > 0)
7987                   break;
7988               if (ent != NULL)
7989                 {
7990                   tga_fd->root.type = bfd_link_hash_indirect;
7991                   tga_fd->root.u.i.link = &opt_fd->root;
7992                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7993                   if (opt_fd->dynindx != -1)
7994                     {
7995                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7996                       opt_fd->dynindx = -1;
7997                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7998                                               opt_fd->dynstr_index);
7999                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8000                         return NULL;
8001                     }
8002                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8003                   tga = &htab->tls_get_addr->elf;
8004                   if (opt != NULL && tga != NULL)
8005                     {
8006                       tga->root.type = bfd_link_hash_indirect;
8007                       tga->root.u.i.link = &opt->root;
8008                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8009                       _bfd_elf_link_hash_hide_symbol (info, opt,
8010                                                       tga->forced_local);
8011                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8012                     }
8013                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8014                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8015                   if (htab->tls_get_addr != NULL)
8016                     {
8017                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8018                       htab->tls_get_addr->is_func = 1;
8019                     }
8020                 }
8021             }
8022         }
8023       else
8024         htab->params->no_tls_get_addr_opt = TRUE;
8025     }
8026   return _bfd_elf_tls_setup (info->output_bfd, info);
8027 }
8028
8029 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8030    HASH1 or HASH2.  */
8031
8032 static bfd_boolean
8033 branch_reloc_hash_match (const bfd *ibfd,
8034                          const Elf_Internal_Rela *rel,
8035                          const struct ppc_link_hash_entry *hash1,
8036                          const struct ppc_link_hash_entry *hash2)
8037 {
8038   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8039   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8040   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8041
8042   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8043     {
8044       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8045       struct elf_link_hash_entry *h;
8046
8047       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8048       h = elf_follow_link (h);
8049       if (h == &hash1->elf || h == &hash2->elf)
8050         return TRUE;
8051     }
8052   return FALSE;
8053 }
8054
8055 /* Run through all the TLS relocs looking for optimization
8056    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8057    a preliminary section layout so that we know the TLS segment
8058    offsets.  We can't optimize earlier because some optimizations need
8059    to know the tp offset, and we need to optimize before allocating
8060    dynamic relocations.  */
8061
8062 bfd_boolean
8063 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8064 {
8065   bfd *ibfd;
8066   asection *sec;
8067   struct ppc_link_hash_table *htab;
8068   unsigned char *toc_ref;
8069   int pass;
8070
8071   if (info->relocatable || !info->executable)
8072     return TRUE;
8073
8074   htab = ppc_hash_table (info);
8075   if (htab == NULL)
8076     return FALSE;
8077
8078   /* Make two passes over the relocs.  On the first pass, mark toc
8079      entries involved with tls relocs, and check that tls relocs
8080      involved in setting up a tls_get_addr call are indeed followed by
8081      such a call.  If they are not, we can't do any tls optimization.
8082      On the second pass twiddle tls_mask flags to notify
8083      relocate_section that optimization can be done, and adjust got
8084      and plt refcounts.  */
8085   toc_ref = NULL;
8086   for (pass = 0; pass < 2; ++pass)
8087     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8088       {
8089         Elf_Internal_Sym *locsyms = NULL;
8090         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8091
8092         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8093           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8094             {
8095               Elf_Internal_Rela *relstart, *rel, *relend;
8096               bfd_boolean found_tls_get_addr_arg = 0;
8097
8098               /* Read the relocations.  */
8099               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8100                                                     info->keep_memory);
8101               if (relstart == NULL)
8102                 {
8103                   free (toc_ref);
8104                   return FALSE;
8105                 }
8106
8107               relend = relstart + sec->reloc_count;
8108               for (rel = relstart; rel < relend; rel++)
8109                 {
8110                   enum elf_ppc64_reloc_type r_type;
8111                   unsigned long r_symndx;
8112                   struct elf_link_hash_entry *h;
8113                   Elf_Internal_Sym *sym;
8114                   asection *sym_sec;
8115                   unsigned char *tls_mask;
8116                   unsigned char tls_set, tls_clear, tls_type = 0;
8117                   bfd_vma value;
8118                   bfd_boolean ok_tprel, is_local;
8119                   long toc_ref_index = 0;
8120                   int expecting_tls_get_addr = 0;
8121                   bfd_boolean ret = FALSE;
8122
8123                   r_symndx = ELF64_R_SYM (rel->r_info);
8124                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8125                                   r_symndx, ibfd))
8126                     {
8127                     err_free_rel:
8128                       if (elf_section_data (sec)->relocs != relstart)
8129                         free (relstart);
8130                       if (toc_ref != NULL)
8131                         free (toc_ref);
8132                       if (locsyms != NULL
8133                           && (elf_symtab_hdr (ibfd).contents
8134                               != (unsigned char *) locsyms))
8135                         free (locsyms);
8136                       return ret;
8137                     }
8138
8139                   if (h != NULL)
8140                     {
8141                       if (h->root.type == bfd_link_hash_defined
8142                           || h->root.type == bfd_link_hash_defweak)
8143                         value = h->root.u.def.value;
8144                       else if (h->root.type == bfd_link_hash_undefweak)
8145                         value = 0;
8146                       else
8147                         {
8148                           found_tls_get_addr_arg = 0;
8149                           continue;
8150                         }
8151                     }
8152                   else
8153                     /* Symbols referenced by TLS relocs must be of type
8154                        STT_TLS.  So no need for .opd local sym adjust.  */
8155                     value = sym->st_value;
8156
8157                   ok_tprel = FALSE;
8158                   is_local = FALSE;
8159                   if (h == NULL
8160                       || !h->def_dynamic)
8161                     {
8162                       is_local = TRUE;
8163                       if (h != NULL
8164                           && h->root.type == bfd_link_hash_undefweak)
8165                         ok_tprel = TRUE;
8166                       else
8167                         {
8168                           value += sym_sec->output_offset;
8169                           value += sym_sec->output_section->vma;
8170                           value -= htab->elf.tls_sec->vma;
8171                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8172                                       < (bfd_vma) 1 << 32);
8173                         }
8174                     }
8175
8176                   r_type = ELF64_R_TYPE (rel->r_info);
8177                   /* If this section has old-style __tls_get_addr calls
8178                      without marker relocs, then check that each
8179                      __tls_get_addr call reloc is preceded by a reloc
8180                      that conceivably belongs to the __tls_get_addr arg
8181                      setup insn.  If we don't find matching arg setup
8182                      relocs, don't do any tls optimization.  */
8183                   if (pass == 0
8184                       && sec->has_tls_get_addr_call
8185                       && h != NULL
8186                       && (h == &htab->tls_get_addr->elf
8187                           || h == &htab->tls_get_addr_fd->elf)
8188                       && !found_tls_get_addr_arg
8189                       && is_branch_reloc (r_type))
8190                     {
8191                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8192                                                 "TLS optimization disabled\n"),
8193                                               ibfd, sec, rel->r_offset);
8194                       ret = TRUE;
8195                       goto err_free_rel;
8196                     }
8197
8198                   found_tls_get_addr_arg = 0;
8199                   switch (r_type)
8200                     {
8201                     case R_PPC64_GOT_TLSLD16:
8202                     case R_PPC64_GOT_TLSLD16_LO:
8203                       expecting_tls_get_addr = 1;
8204                       found_tls_get_addr_arg = 1;
8205                       /* Fall thru */
8206
8207                     case R_PPC64_GOT_TLSLD16_HI:
8208                     case R_PPC64_GOT_TLSLD16_HA:
8209                       /* These relocs should never be against a symbol
8210                          defined in a shared lib.  Leave them alone if
8211                          that turns out to be the case.  */
8212                       if (!is_local)
8213                         continue;
8214
8215                       /* LD -> LE */
8216                       tls_set = 0;
8217                       tls_clear = TLS_LD;
8218                       tls_type = TLS_TLS | TLS_LD;
8219                       break;
8220
8221                     case R_PPC64_GOT_TLSGD16:
8222                     case R_PPC64_GOT_TLSGD16_LO:
8223                       expecting_tls_get_addr = 1;
8224                       found_tls_get_addr_arg = 1;
8225                       /* Fall thru */
8226
8227                     case R_PPC64_GOT_TLSGD16_HI:
8228                     case R_PPC64_GOT_TLSGD16_HA:
8229                       if (ok_tprel)
8230                         /* GD -> LE */
8231                         tls_set = 0;
8232                       else
8233                         /* GD -> IE */
8234                         tls_set = TLS_TLS | TLS_TPRELGD;
8235                       tls_clear = TLS_GD;
8236                       tls_type = TLS_TLS | TLS_GD;
8237                       break;
8238
8239                     case R_PPC64_GOT_TPREL16_DS:
8240                     case R_PPC64_GOT_TPREL16_LO_DS:
8241                     case R_PPC64_GOT_TPREL16_HI:
8242                     case R_PPC64_GOT_TPREL16_HA:
8243                       if (ok_tprel)
8244                         {
8245                           /* IE -> LE */
8246                           tls_set = 0;
8247                           tls_clear = TLS_TPREL;
8248                           tls_type = TLS_TLS | TLS_TPREL;
8249                           break;
8250                         }
8251                       continue;
8252
8253                     case R_PPC64_TLSGD:
8254                     case R_PPC64_TLSLD:
8255                       found_tls_get_addr_arg = 1;
8256                       /* Fall thru */
8257
8258                     case R_PPC64_TLS:
8259                     case R_PPC64_TOC16:
8260                     case R_PPC64_TOC16_LO:
8261                       if (sym_sec == NULL || sym_sec != toc)
8262                         continue;
8263
8264                       /* Mark this toc entry as referenced by a TLS
8265                          code sequence.  We can do that now in the
8266                          case of R_PPC64_TLS, and after checking for
8267                          tls_get_addr for the TOC16 relocs.  */
8268                       if (toc_ref == NULL)
8269                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8270                       if (toc_ref == NULL)
8271                         goto err_free_rel;
8272
8273                       if (h != NULL)
8274                         value = h->root.u.def.value;
8275                       else
8276                         value = sym->st_value;
8277                       value += rel->r_addend;
8278                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8279                       toc_ref_index = (value + toc->output_offset) / 8;
8280                       if (r_type == R_PPC64_TLS
8281                           || r_type == R_PPC64_TLSGD
8282                           || r_type == R_PPC64_TLSLD)
8283                         {
8284                           toc_ref[toc_ref_index] = 1;
8285                           continue;
8286                         }
8287
8288                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8289                         continue;
8290
8291                       tls_set = 0;
8292                       tls_clear = 0;
8293                       expecting_tls_get_addr = 2;
8294                       break;
8295
8296                     case R_PPC64_TPREL64:
8297                       if (pass == 0
8298                           || sec != toc
8299                           || toc_ref == NULL
8300                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8301                         continue;
8302                       if (ok_tprel)
8303                         {
8304                           /* IE -> LE */
8305                           tls_set = TLS_EXPLICIT;
8306                           tls_clear = TLS_TPREL;
8307                           break;
8308                         }
8309                       continue;
8310
8311                     case R_PPC64_DTPMOD64:
8312                       if (pass == 0
8313                           || sec != toc
8314                           || toc_ref == NULL
8315                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8316                         continue;
8317                       if (rel + 1 < relend
8318                           && (rel[1].r_info
8319                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8320                           && rel[1].r_offset == rel->r_offset + 8)
8321                         {
8322                           if (ok_tprel)
8323                             /* GD -> LE */
8324                             tls_set = TLS_EXPLICIT | TLS_GD;
8325                           else
8326                             /* GD -> IE */
8327                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8328                           tls_clear = TLS_GD;
8329                         }
8330                       else
8331                         {
8332                           if (!is_local)
8333                             continue;
8334
8335                           /* LD -> LE */
8336                           tls_set = TLS_EXPLICIT;
8337                           tls_clear = TLS_LD;
8338                         }
8339                       break;
8340
8341                     default:
8342                       continue;
8343                     }
8344
8345                   if (pass == 0)
8346                     {
8347                       if (!expecting_tls_get_addr
8348                           || !sec->has_tls_get_addr_call)
8349                         continue;
8350
8351                       if (rel + 1 < relend
8352                           && branch_reloc_hash_match (ibfd, rel + 1,
8353                                                       htab->tls_get_addr,
8354                                                       htab->tls_get_addr_fd))
8355                         {
8356                           if (expecting_tls_get_addr == 2)
8357                             {
8358                               /* Check for toc tls entries.  */
8359                               unsigned char *toc_tls;
8360                               int retval;
8361
8362                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8363                                                      &locsyms,
8364                                                      rel, ibfd);
8365                               if (retval == 0)
8366                                 goto err_free_rel;
8367                               if (toc_tls != NULL)
8368                                 {
8369                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8370                                     found_tls_get_addr_arg = 1;
8371                                   if (retval > 1)
8372                                     toc_ref[toc_ref_index] = 1;
8373                                 }
8374                             }
8375                           continue;
8376                         }
8377
8378                       if (expecting_tls_get_addr != 1)
8379                         continue;
8380
8381                       /* Uh oh, we didn't find the expected call.  We
8382                          could just mark this symbol to exclude it
8383                          from tls optimization but it's safer to skip
8384                          the entire optimization.  */
8385                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8386                                                 "TLS optimization disabled\n"),
8387                                               ibfd, sec, rel->r_offset);
8388                       ret = TRUE;
8389                       goto err_free_rel;
8390                     }
8391
8392                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8393                     {
8394                       struct plt_entry *ent;
8395                       for (ent = htab->tls_get_addr->elf.plt.plist;
8396                            ent != NULL;
8397                            ent = ent->next)
8398                         if (ent->addend == 0)
8399                           {
8400                             if (ent->plt.refcount > 0)
8401                               {
8402                                 ent->plt.refcount -= 1;
8403                                 expecting_tls_get_addr = 0;
8404                               }
8405                             break;
8406                           }
8407                     }
8408
8409                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8410                     {
8411                       struct plt_entry *ent;
8412                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8413                            ent != NULL;
8414                            ent = ent->next)
8415                         if (ent->addend == 0)
8416                           {
8417                             if (ent->plt.refcount > 0)
8418                               ent->plt.refcount -= 1;
8419                             break;
8420                           }
8421                     }
8422
8423                   if (tls_clear == 0)
8424                     continue;
8425
8426                   if ((tls_set & TLS_EXPLICIT) == 0)
8427                     {
8428                       struct got_entry *ent;
8429
8430                       /* Adjust got entry for this reloc.  */
8431                       if (h != NULL)
8432                         ent = h->got.glist;
8433                       else
8434                         ent = elf_local_got_ents (ibfd)[r_symndx];
8435
8436                       for (; ent != NULL; ent = ent->next)
8437                         if (ent->addend == rel->r_addend
8438                             && ent->owner == ibfd
8439                             && ent->tls_type == tls_type)
8440                           break;
8441                       if (ent == NULL)
8442                         abort ();
8443
8444                       if (tls_set == 0)
8445                         {
8446                           /* We managed to get rid of a got entry.  */
8447                           if (ent->got.refcount > 0)
8448                             ent->got.refcount -= 1;
8449                         }
8450                     }
8451                   else
8452                     {
8453                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8454                          we'll lose one or two dyn relocs.  */
8455                       if (!dec_dynrel_count (rel->r_info, sec, info,
8456                                              NULL, h, sym))
8457                         return FALSE;
8458
8459                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8460                         {
8461                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8462                                                  NULL, h, sym))
8463                             return FALSE;
8464                         }
8465                     }
8466
8467                   *tls_mask |= tls_set;
8468                   *tls_mask &= ~tls_clear;
8469                 }
8470
8471               if (elf_section_data (sec)->relocs != relstart)
8472                 free (relstart);
8473             }
8474
8475         if (locsyms != NULL
8476             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8477           {
8478             if (!info->keep_memory)
8479               free (locsyms);
8480             else
8481               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8482           }
8483       }
8484
8485   if (toc_ref != NULL)
8486     free (toc_ref);
8487   return TRUE;
8488 }
8489
8490 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8491    the values of any global symbols in a toc section that has been
8492    edited.  Globals in toc sections should be a rarity, so this function
8493    sets a flag if any are found in toc sections other than the one just
8494    edited, so that futher hash table traversals can be avoided.  */
8495
8496 struct adjust_toc_info
8497 {
8498   asection *toc;
8499   unsigned long *skip;
8500   bfd_boolean global_toc_syms;
8501 };
8502
8503 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8504
8505 static bfd_boolean
8506 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8507 {
8508   struct ppc_link_hash_entry *eh;
8509   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8510   unsigned long i;
8511
8512   if (h->root.type != bfd_link_hash_defined
8513       && h->root.type != bfd_link_hash_defweak)
8514     return TRUE;
8515
8516   eh = (struct ppc_link_hash_entry *) h;
8517   if (eh->adjust_done)
8518     return TRUE;
8519
8520   if (eh->elf.root.u.def.section == toc_inf->toc)
8521     {
8522       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8523         i = toc_inf->toc->rawsize >> 3;
8524       else
8525         i = eh->elf.root.u.def.value >> 3;
8526
8527       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8528         {
8529           (*_bfd_error_handler)
8530             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8531           do
8532             ++i;
8533           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8534           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8535         }
8536
8537       eh->elf.root.u.def.value -= toc_inf->skip[i];
8538       eh->adjust_done = 1;
8539     }
8540   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8541     toc_inf->global_toc_syms = TRUE;
8542
8543   return TRUE;
8544 }
8545
8546 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8547
8548 static bfd_boolean
8549 ok_lo_toc_insn (unsigned int insn)
8550 {
8551   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8552           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8553           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8554           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8555           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8556           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8557           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8558           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8559           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8560           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8561           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8562           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8563           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8564           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8565           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8566               && (insn & 3) != 1)
8567           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8568               && ((insn & 3) == 0 || (insn & 3) == 3))
8569           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8570 }
8571
8572 /* Examine all relocs referencing .toc sections in order to remove
8573    unused .toc entries.  */
8574
8575 bfd_boolean
8576 ppc64_elf_edit_toc (struct bfd_link_info *info)
8577 {
8578   bfd *ibfd;
8579   struct adjust_toc_info toc_inf;
8580   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8581
8582   htab->do_toc_opt = 1;
8583   toc_inf.global_toc_syms = TRUE;
8584   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8585     {
8586       asection *toc, *sec;
8587       Elf_Internal_Shdr *symtab_hdr;
8588       Elf_Internal_Sym *local_syms;
8589       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8590       unsigned long *skip, *drop;
8591       unsigned char *used;
8592       unsigned char *keep, last, some_unused;
8593
8594       if (!is_ppc64_elf (ibfd))
8595         continue;
8596
8597       toc = bfd_get_section_by_name (ibfd, ".toc");
8598       if (toc == NULL
8599           || toc->size == 0
8600           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8601           || discarded_section (toc))
8602         continue;
8603
8604       toc_relocs = NULL;
8605       local_syms = NULL;
8606       symtab_hdr = &elf_symtab_hdr (ibfd);
8607
8608       /* Look at sections dropped from the final link.  */
8609       skip = NULL;
8610       relstart = NULL;
8611       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8612         {
8613           if (sec->reloc_count == 0
8614               || !discarded_section (sec)
8615               || get_opd_info (sec)
8616               || (sec->flags & SEC_ALLOC) == 0
8617               || (sec->flags & SEC_DEBUGGING) != 0)
8618             continue;
8619
8620           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8621           if (relstart == NULL)
8622             goto error_ret;
8623
8624           /* Run through the relocs to see which toc entries might be
8625              unused.  */
8626           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8627             {
8628               enum elf_ppc64_reloc_type r_type;
8629               unsigned long r_symndx;
8630               asection *sym_sec;
8631               struct elf_link_hash_entry *h;
8632               Elf_Internal_Sym *sym;
8633               bfd_vma val;
8634
8635               r_type = ELF64_R_TYPE (rel->r_info);
8636               switch (r_type)
8637                 {
8638                 default:
8639                   continue;
8640
8641                 case R_PPC64_TOC16:
8642                 case R_PPC64_TOC16_LO:
8643                 case R_PPC64_TOC16_HI:
8644                 case R_PPC64_TOC16_HA:
8645                 case R_PPC64_TOC16_DS:
8646                 case R_PPC64_TOC16_LO_DS:
8647                   break;
8648                 }
8649
8650               r_symndx = ELF64_R_SYM (rel->r_info);
8651               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8652                               r_symndx, ibfd))
8653                 goto error_ret;
8654
8655               if (sym_sec != toc)
8656                 continue;
8657
8658               if (h != NULL)
8659                 val = h->root.u.def.value;
8660               else
8661                 val = sym->st_value;
8662               val += rel->r_addend;
8663
8664               if (val >= toc->size)
8665                 continue;
8666
8667               /* Anything in the toc ought to be aligned to 8 bytes.
8668                  If not, don't mark as unused.  */
8669               if (val & 7)
8670                 continue;
8671
8672               if (skip == NULL)
8673                 {
8674                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8675                   if (skip == NULL)
8676                     goto error_ret;
8677                 }
8678
8679               skip[val >> 3] = ref_from_discarded;
8680             }
8681
8682           if (elf_section_data (sec)->relocs != relstart)
8683             free (relstart);
8684         }
8685
8686       /* For largetoc loads of address constants, we can convert
8687          .  addis rx,2,addr@got@ha
8688          .  ld ry,addr@got@l(rx)
8689          to
8690          .  addis rx,2,addr@toc@ha
8691          .  addi ry,rx,addr@toc@l
8692          when addr is within 2G of the toc pointer.  This then means
8693          that the word storing "addr" in the toc is no longer needed.  */
8694
8695       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8696           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8697           && toc->reloc_count != 0)
8698         {
8699           /* Read toc relocs.  */
8700           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8701                                                   info->keep_memory);
8702           if (toc_relocs == NULL)
8703             goto error_ret;
8704
8705           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8706             {
8707               enum elf_ppc64_reloc_type r_type;
8708               unsigned long r_symndx;
8709               asection *sym_sec;
8710               struct elf_link_hash_entry *h;
8711               Elf_Internal_Sym *sym;
8712               bfd_vma val, addr;
8713
8714               r_type = ELF64_R_TYPE (rel->r_info);
8715               if (r_type != R_PPC64_ADDR64)
8716                 continue;
8717
8718               r_symndx = ELF64_R_SYM (rel->r_info);
8719               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8720                               r_symndx, ibfd))
8721                 goto error_ret;
8722
8723               if (sym_sec == NULL
8724                   || discarded_section (sym_sec))
8725                 continue;
8726
8727               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8728                 continue;
8729
8730               if (h != NULL)
8731                 {
8732                   if (h->type == STT_GNU_IFUNC)
8733                     continue;
8734                   val = h->root.u.def.value;
8735                 }
8736               else
8737                 {
8738                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8739                     continue;
8740                   val = sym->st_value;
8741                 }
8742               val += rel->r_addend;
8743               val += sym_sec->output_section->vma + sym_sec->output_offset;
8744
8745               /* We don't yet know the exact toc pointer value, but we
8746                  know it will be somewhere in the toc section.  Don't
8747                  optimize if the difference from any possible toc
8748                  pointer is outside [ff..f80008000, 7fff7fff].  */
8749               addr = toc->output_section->vma + TOC_BASE_OFF;
8750               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8751                 continue;
8752
8753               addr = toc->output_section->vma + toc->output_section->rawsize;
8754               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8755                 continue;
8756
8757               if (skip == NULL)
8758                 {
8759                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8760                   if (skip == NULL)
8761                     goto error_ret;
8762                 }
8763
8764               skip[rel->r_offset >> 3]
8765                 |= can_optimize | ((rel - toc_relocs) << 2);
8766             }
8767         }
8768
8769       if (skip == NULL)
8770         continue;
8771
8772       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8773       if (used == NULL)
8774         {
8775         error_ret:
8776           if (local_syms != NULL
8777               && symtab_hdr->contents != (unsigned char *) local_syms)
8778             free (local_syms);
8779           if (sec != NULL
8780               && relstart != NULL
8781               && elf_section_data (sec)->relocs != relstart)
8782             free (relstart);
8783           if (toc_relocs != NULL
8784               && elf_section_data (toc)->relocs != toc_relocs)
8785             free (toc_relocs);
8786           if (skip != NULL)
8787             free (skip);
8788           return FALSE;
8789         }
8790
8791       /* Now check all kept sections that might reference the toc.
8792          Check the toc itself last.  */
8793       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8794                   : ibfd->sections);
8795            sec != NULL;
8796            sec = (sec == toc ? NULL
8797                   : sec->next == NULL ? toc
8798                   : sec->next == toc && toc->next ? toc->next
8799                   : sec->next))
8800         {
8801           int repeat;
8802
8803           if (sec->reloc_count == 0
8804               || discarded_section (sec)
8805               || get_opd_info (sec)
8806               || (sec->flags & SEC_ALLOC) == 0
8807               || (sec->flags & SEC_DEBUGGING) != 0)
8808             continue;
8809
8810           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8811                                                 info->keep_memory);
8812           if (relstart == NULL)
8813             {
8814               free (used);
8815               goto error_ret;
8816             }
8817
8818           /* Mark toc entries referenced as used.  */
8819           do
8820             {
8821               repeat = 0;
8822               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8823                 {
8824                   enum elf_ppc64_reloc_type r_type;
8825                   unsigned long r_symndx;
8826                   asection *sym_sec;
8827                   struct elf_link_hash_entry *h;
8828                   Elf_Internal_Sym *sym;
8829                   bfd_vma val;
8830                   enum {no_check, check_lo, check_ha} insn_check;
8831
8832                   r_type = ELF64_R_TYPE (rel->r_info);
8833                   switch (r_type)
8834                     {
8835                     default:
8836                       insn_check = no_check;
8837                       break;
8838
8839                     case R_PPC64_GOT_TLSLD16_HA:
8840                     case R_PPC64_GOT_TLSGD16_HA:
8841                     case R_PPC64_GOT_TPREL16_HA:
8842                     case R_PPC64_GOT_DTPREL16_HA:
8843                     case R_PPC64_GOT16_HA:
8844                     case R_PPC64_TOC16_HA:
8845                       insn_check = check_ha;
8846                       break;
8847
8848                     case R_PPC64_GOT_TLSLD16_LO:
8849                     case R_PPC64_GOT_TLSGD16_LO:
8850                     case R_PPC64_GOT_TPREL16_LO_DS:
8851                     case R_PPC64_GOT_DTPREL16_LO_DS:
8852                     case R_PPC64_GOT16_LO:
8853                     case R_PPC64_GOT16_LO_DS:
8854                     case R_PPC64_TOC16_LO:
8855                     case R_PPC64_TOC16_LO_DS:
8856                       insn_check = check_lo;
8857                       break;
8858                     }
8859
8860                   if (insn_check != no_check)
8861                     {
8862                       bfd_vma off = rel->r_offset & ~3;
8863                       unsigned char buf[4];
8864                       unsigned int insn;
8865
8866                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8867                         {
8868                           free (used);
8869                           goto error_ret;
8870                         }
8871                       insn = bfd_get_32 (ibfd, buf);
8872                       if (insn_check == check_lo
8873                           ? !ok_lo_toc_insn (insn)
8874                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8875                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8876                         {
8877                           char str[12];
8878
8879                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8880                           sprintf (str, "%#08x", insn);
8881                           info->callbacks->einfo
8882                             (_("%P: %H: toc optimization is not supported for"
8883                                " %s instruction.\n"),
8884                              ibfd, sec, rel->r_offset & ~3, str);
8885                         }
8886                     }
8887
8888                   switch (r_type)
8889                     {
8890                     case R_PPC64_TOC16:
8891                     case R_PPC64_TOC16_LO:
8892                     case R_PPC64_TOC16_HI:
8893                     case R_PPC64_TOC16_HA:
8894                     case R_PPC64_TOC16_DS:
8895                     case R_PPC64_TOC16_LO_DS:
8896                       /* In case we're taking addresses of toc entries.  */
8897                     case R_PPC64_ADDR64:
8898                       break;
8899
8900                     default:
8901                       continue;
8902                     }
8903
8904                   r_symndx = ELF64_R_SYM (rel->r_info);
8905                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8906                                   r_symndx, ibfd))
8907                     {
8908                       free (used);
8909                       goto error_ret;
8910                     }
8911
8912                   if (sym_sec != toc)
8913                     continue;
8914
8915                   if (h != NULL)
8916                     val = h->root.u.def.value;
8917                   else
8918                     val = sym->st_value;
8919                   val += rel->r_addend;
8920
8921                   if (val >= toc->size)
8922                     continue;
8923
8924                   if ((skip[val >> 3] & can_optimize) != 0)
8925                     {
8926                       bfd_vma off;
8927                       unsigned char opc;
8928
8929                       switch (r_type)
8930                         {
8931                         case R_PPC64_TOC16_HA:
8932                           break;
8933
8934                         case R_PPC64_TOC16_LO_DS:
8935                           off = rel->r_offset;
8936                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8937                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8938                                                          off, 1))
8939                             {
8940                               free (used);
8941                               goto error_ret;
8942                             }
8943                           if ((opc & (0x3f << 2)) == (58u << 2))
8944                             break;
8945                           /* Fall thru */
8946
8947                         default:
8948                           /* Wrong sort of reloc, or not a ld.  We may
8949                              as well clear ref_from_discarded too.  */
8950                           skip[val >> 3] = 0;
8951                         }
8952                     }
8953
8954                   if (sec != toc)
8955                     used[val >> 3] = 1;
8956                   /* For the toc section, we only mark as used if this
8957                      entry itself isn't unused.  */
8958                   else if ((used[rel->r_offset >> 3]
8959                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8960                            && !used[val >> 3])
8961                     {
8962                       /* Do all the relocs again, to catch reference
8963                          chains.  */
8964                       repeat = 1;
8965                       used[val >> 3] = 1;
8966                     }
8967                 }
8968             }
8969           while (repeat);
8970
8971           if (elf_section_data (sec)->relocs != relstart)
8972             free (relstart);
8973         }
8974
8975       /* Merge the used and skip arrays.  Assume that TOC
8976          doublewords not appearing as either used or unused belong
8977          to to an entry more than one doubleword in size.  */
8978       for (drop = skip, keep = used, last = 0, some_unused = 0;
8979            drop < skip + (toc->size + 7) / 8;
8980            ++drop, ++keep)
8981         {
8982           if (*keep)
8983             {
8984               *drop &= ~ref_from_discarded;
8985               if ((*drop & can_optimize) != 0)
8986                 some_unused = 1;
8987               last = 0;
8988             }
8989           else if ((*drop & ref_from_discarded) != 0)
8990             {
8991               some_unused = 1;
8992               last = ref_from_discarded;
8993             }
8994           else
8995             *drop = last;
8996         }
8997
8998       free (used);
8999
9000       if (some_unused)
9001         {
9002           bfd_byte *contents, *src;
9003           unsigned long off;
9004           Elf_Internal_Sym *sym;
9005           bfd_boolean local_toc_syms = FALSE;
9006
9007           /* Shuffle the toc contents, and at the same time convert the
9008              skip array from booleans into offsets.  */
9009           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9010             goto error_ret;
9011
9012           elf_section_data (toc)->this_hdr.contents = contents;
9013
9014           for (src = contents, off = 0, drop = skip;
9015                src < contents + toc->size;
9016                src += 8, ++drop)
9017             {
9018               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9019                 off += 8;
9020               else if (off != 0)
9021                 {
9022                   *drop = off;
9023                   memcpy (src - off, src, 8);
9024                 }
9025             }
9026           *drop = off;
9027           toc->rawsize = toc->size;
9028           toc->size = src - contents - off;
9029
9030           /* Adjust addends for relocs against the toc section sym,
9031              and optimize any accesses we can.  */
9032           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9033             {
9034               if (sec->reloc_count == 0
9035                   || discarded_section (sec))
9036                 continue;
9037
9038               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9039                                                     info->keep_memory);
9040               if (relstart == NULL)
9041                 goto error_ret;
9042
9043               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9044                 {
9045                   enum elf_ppc64_reloc_type r_type;
9046                   unsigned long r_symndx;
9047                   asection *sym_sec;
9048                   struct elf_link_hash_entry *h;
9049                   bfd_vma val;
9050
9051                   r_type = ELF64_R_TYPE (rel->r_info);
9052                   switch (r_type)
9053                     {
9054                     default:
9055                       continue;
9056
9057                     case R_PPC64_TOC16:
9058                     case R_PPC64_TOC16_LO:
9059                     case R_PPC64_TOC16_HI:
9060                     case R_PPC64_TOC16_HA:
9061                     case R_PPC64_TOC16_DS:
9062                     case R_PPC64_TOC16_LO_DS:
9063                     case R_PPC64_ADDR64:
9064                       break;
9065                     }
9066
9067                   r_symndx = ELF64_R_SYM (rel->r_info);
9068                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9069                                   r_symndx, ibfd))
9070                     goto error_ret;
9071
9072                   if (sym_sec != toc)
9073                     continue;
9074
9075                   if (h != NULL)
9076                     val = h->root.u.def.value;
9077                   else
9078                     {
9079                       val = sym->st_value;
9080                       if (val != 0)
9081                         local_toc_syms = TRUE;
9082                     }
9083
9084                   val += rel->r_addend;
9085
9086                   if (val > toc->rawsize)
9087                     val = toc->rawsize;
9088                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9089                     continue;
9090                   else if ((skip[val >> 3] & can_optimize) != 0)
9091                     {
9092                       Elf_Internal_Rela *tocrel
9093                         = toc_relocs + (skip[val >> 3] >> 2);
9094                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9095
9096                       switch (r_type)
9097                         {
9098                         case R_PPC64_TOC16_HA:
9099                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9100                           break;
9101
9102                         case R_PPC64_TOC16_LO_DS:
9103                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9104                           break;
9105
9106                         default:
9107                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9108                             ppc_howto_init ();
9109                           info->callbacks->einfo
9110                             (_("%P: %H: %s references "
9111                                "optimized away TOC entry\n"),
9112                              ibfd, sec, rel->r_offset,
9113                              ppc64_elf_howto_table[r_type]->name);
9114                           bfd_set_error (bfd_error_bad_value);
9115                           goto error_ret;
9116                         }
9117                       rel->r_addend = tocrel->r_addend;
9118                       elf_section_data (sec)->relocs = relstart;
9119                       continue;
9120                     }
9121
9122                   if (h != NULL || sym->st_value != 0)
9123                     continue;
9124
9125                   rel->r_addend -= skip[val >> 3];
9126                   elf_section_data (sec)->relocs = relstart;
9127                 }
9128
9129               if (elf_section_data (sec)->relocs != relstart)
9130                 free (relstart);
9131             }
9132
9133           /* We shouldn't have local or global symbols defined in the TOC,
9134              but handle them anyway.  */
9135           if (local_syms != NULL)
9136             for (sym = local_syms;
9137                  sym < local_syms + symtab_hdr->sh_info;
9138                  ++sym)
9139               if (sym->st_value != 0
9140                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9141                 {
9142                   unsigned long i;
9143
9144                   if (sym->st_value > toc->rawsize)
9145                     i = toc->rawsize >> 3;
9146                   else
9147                     i = sym->st_value >> 3;
9148
9149                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9150                     {
9151                       if (local_toc_syms)
9152                         (*_bfd_error_handler)
9153                           (_("%s defined on removed toc entry"),
9154                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9155                       do
9156                         ++i;
9157                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9158                       sym->st_value = (bfd_vma) i << 3;
9159                     }
9160
9161                   sym->st_value -= skip[i];
9162                   symtab_hdr->contents = (unsigned char *) local_syms;
9163                 }
9164
9165           /* Adjust any global syms defined in this toc input section.  */
9166           if (toc_inf.global_toc_syms)
9167             {
9168               toc_inf.toc = toc;
9169               toc_inf.skip = skip;
9170               toc_inf.global_toc_syms = FALSE;
9171               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9172                                       &toc_inf);
9173             }
9174
9175           if (toc->reloc_count != 0)
9176             {
9177               Elf_Internal_Shdr *rel_hdr;
9178               Elf_Internal_Rela *wrel;
9179               bfd_size_type sz;
9180
9181               /* Remove unused toc relocs, and adjust those we keep.  */
9182               if (toc_relocs == NULL)
9183                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9184                                                         info->keep_memory);
9185               if (toc_relocs == NULL)
9186                 goto error_ret;
9187
9188               wrel = toc_relocs;
9189               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9190                 if ((skip[rel->r_offset >> 3]
9191                      & (ref_from_discarded | can_optimize)) == 0)
9192                   {
9193                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9194                     wrel->r_info = rel->r_info;
9195                     wrel->r_addend = rel->r_addend;
9196                     ++wrel;
9197                   }
9198                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9199                                             &local_syms, NULL, NULL))
9200                   goto error_ret;
9201
9202               elf_section_data (toc)->relocs = toc_relocs;
9203               toc->reloc_count = wrel - toc_relocs;
9204               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9205               sz = rel_hdr->sh_entsize;
9206               rel_hdr->sh_size = toc->reloc_count * sz;
9207             }
9208         }
9209       else if (toc_relocs != NULL
9210                && elf_section_data (toc)->relocs != toc_relocs)
9211         free (toc_relocs);
9212
9213       if (local_syms != NULL
9214           && symtab_hdr->contents != (unsigned char *) local_syms)
9215         {
9216           if (!info->keep_memory)
9217             free (local_syms);
9218           else
9219             symtab_hdr->contents = (unsigned char *) local_syms;
9220         }
9221       free (skip);
9222     }
9223
9224   return TRUE;
9225 }
9226
9227 /* Return true iff input section I references the TOC using
9228    instructions limited to +/-32k offsets.  */
9229
9230 bfd_boolean
9231 ppc64_elf_has_small_toc_reloc (asection *i)
9232 {
9233   return (is_ppc64_elf (i->owner)
9234           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9235 }
9236
9237 /* Allocate space for one GOT entry.  */
9238
9239 static void
9240 allocate_got (struct elf_link_hash_entry *h,
9241               struct bfd_link_info *info,
9242               struct got_entry *gent)
9243 {
9244   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9245   bfd_boolean dyn;
9246   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9247   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9248                  ? 16 : 8);
9249   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9250                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9251   asection *got = ppc64_elf_tdata (gent->owner)->got;
9252
9253   gent->got.offset = got->size;
9254   got->size += entsize;
9255
9256   dyn = htab->elf.dynamic_sections_created;
9257   if (h->type == STT_GNU_IFUNC)
9258     {
9259       htab->elf.irelplt->size += rentsize;
9260       htab->got_reli_size += rentsize;
9261     }
9262   else if ((info->shared
9263             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9264            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9265                || h->root.type != bfd_link_hash_undefweak))
9266     {
9267       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9268       relgot->size += rentsize;
9269     }
9270 }
9271
9272 /* This function merges got entries in the same toc group.  */
9273
9274 static void
9275 merge_got_entries (struct got_entry **pent)
9276 {
9277   struct got_entry *ent, *ent2;
9278
9279   for (ent = *pent; ent != NULL; ent = ent->next)
9280     if (!ent->is_indirect)
9281       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9282         if (!ent2->is_indirect
9283             && ent2->addend == ent->addend
9284             && ent2->tls_type == ent->tls_type
9285             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9286           {
9287             ent2->is_indirect = TRUE;
9288             ent2->got.ent = ent;
9289           }
9290 }
9291
9292 /* Allocate space in .plt, .got and associated reloc sections for
9293    dynamic relocs.  */
9294
9295 static bfd_boolean
9296 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9297 {
9298   struct bfd_link_info *info;
9299   struct ppc_link_hash_table *htab;
9300   asection *s;
9301   struct ppc_link_hash_entry *eh;
9302   struct elf_dyn_relocs *p;
9303   struct got_entry **pgent, *gent;
9304
9305   if (h->root.type == bfd_link_hash_indirect)
9306     return TRUE;
9307
9308   info = (struct bfd_link_info *) inf;
9309   htab = ppc_hash_table (info);
9310   if (htab == NULL)
9311     return FALSE;
9312
9313   if ((htab->elf.dynamic_sections_created
9314        && h->dynindx != -1
9315        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9316       || h->type == STT_GNU_IFUNC)
9317     {
9318       struct plt_entry *pent;
9319       bfd_boolean doneone = FALSE;
9320       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9321         if (pent->plt.refcount > 0)
9322           {
9323             if (!htab->elf.dynamic_sections_created
9324                 || h->dynindx == -1)
9325               {
9326                 s = htab->elf.iplt;
9327                 pent->plt.offset = s->size;
9328                 s->size += PLT_ENTRY_SIZE (htab);
9329                 s = htab->elf.irelplt;
9330               }
9331             else
9332               {
9333                 /* If this is the first .plt entry, make room for the special
9334                    first entry.  */
9335                 s = htab->elf.splt;
9336                 if (s->size == 0)
9337                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9338
9339                 pent->plt.offset = s->size;
9340
9341                 /* Make room for this entry.  */
9342                 s->size += PLT_ENTRY_SIZE (htab);
9343
9344                 /* Make room for the .glink code.  */
9345                 s = htab->glink;
9346                 if (s->size == 0)
9347                   s->size += GLINK_CALL_STUB_SIZE;
9348                 if (htab->opd_abi)
9349                   {
9350                     /* We need bigger stubs past index 32767.  */
9351                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9352                       s->size += 4;
9353                     s->size += 2*4;
9354                   }
9355                 else
9356                   s->size += 4;
9357
9358                 /* We also need to make an entry in the .rela.plt section.  */
9359                 s = htab->elf.srelplt;
9360               }
9361             s->size += sizeof (Elf64_External_Rela);
9362             doneone = TRUE;
9363           }
9364         else
9365           pent->plt.offset = (bfd_vma) -1;
9366       if (!doneone)
9367         {
9368           h->plt.plist = NULL;
9369           h->needs_plt = 0;
9370         }
9371     }
9372   else
9373     {
9374       h->plt.plist = NULL;
9375       h->needs_plt = 0;
9376     }
9377
9378   eh = (struct ppc_link_hash_entry *) h;
9379   /* Run through the TLS GD got entries first if we're changing them
9380      to TPREL.  */
9381   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9382     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9383       if (gent->got.refcount > 0
9384           && (gent->tls_type & TLS_GD) != 0)
9385         {
9386           /* This was a GD entry that has been converted to TPREL.  If
9387              there happens to be a TPREL entry we can use that one.  */
9388           struct got_entry *ent;
9389           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9390             if (ent->got.refcount > 0
9391                 && (ent->tls_type & TLS_TPREL) != 0
9392                 && ent->addend == gent->addend
9393                 && ent->owner == gent->owner)
9394               {
9395                 gent->got.refcount = 0;
9396                 break;
9397               }
9398
9399           /* If not, then we'll be using our own TPREL entry.  */
9400           if (gent->got.refcount != 0)
9401             gent->tls_type = TLS_TLS | TLS_TPREL;
9402         }
9403
9404   /* Remove any list entry that won't generate a word in the GOT before
9405      we call merge_got_entries.  Otherwise we risk merging to empty
9406      entries.  */
9407   pgent = &h->got.glist;
9408   while ((gent = *pgent) != NULL)
9409     if (gent->got.refcount > 0)
9410       {
9411         if ((gent->tls_type & TLS_LD) != 0
9412             && !h->def_dynamic)
9413           {
9414             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9415             *pgent = gent->next;
9416           }
9417         else
9418           pgent = &gent->next;
9419       }
9420     else
9421       *pgent = gent->next;
9422
9423   if (!htab->do_multi_toc)
9424     merge_got_entries (&h->got.glist);
9425
9426   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9427     if (!gent->is_indirect)
9428       {
9429         /* Make sure this symbol is output as a dynamic symbol.
9430            Undefined weak syms won't yet be marked as dynamic,
9431            nor will all TLS symbols.  */
9432         if (h->dynindx == -1
9433             && !h->forced_local
9434             && h->type != STT_GNU_IFUNC
9435             && htab->elf.dynamic_sections_created)
9436           {
9437             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9438               return FALSE;
9439           }
9440
9441         if (!is_ppc64_elf (gent->owner))
9442           abort ();
9443
9444         allocate_got (h, info, gent);
9445       }
9446
9447   if (eh->dyn_relocs == NULL
9448       || (!htab->elf.dynamic_sections_created
9449           && h->type != STT_GNU_IFUNC))
9450     return TRUE;
9451
9452   /* In the shared -Bsymbolic case, discard space allocated for
9453      dynamic pc-relative relocs against symbols which turn out to be
9454      defined in regular objects.  For the normal shared case, discard
9455      space for relocs that have become local due to symbol visibility
9456      changes.  */
9457
9458   if (info->shared)
9459     {
9460       /* Relocs that use pc_count are those that appear on a call insn,
9461          or certain REL relocs (see must_be_dyn_reloc) that can be
9462          generated via assembly.  We want calls to protected symbols to
9463          resolve directly to the function rather than going via the plt.
9464          If people want function pointer comparisons to work as expected
9465          then they should avoid writing weird assembly.  */
9466       if (SYMBOL_CALLS_LOCAL (info, h))
9467         {
9468           struct elf_dyn_relocs **pp;
9469
9470           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9471             {
9472               p->count -= p->pc_count;
9473               p->pc_count = 0;
9474               if (p->count == 0)
9475                 *pp = p->next;
9476               else
9477                 pp = &p->next;
9478             }
9479         }
9480
9481       /* Also discard relocs on undefined weak syms with non-default
9482          visibility.  */
9483       if (eh->dyn_relocs != NULL
9484           && h->root.type == bfd_link_hash_undefweak)
9485         {
9486           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9487             eh->dyn_relocs = NULL;
9488
9489           /* Make sure this symbol is output as a dynamic symbol.
9490              Undefined weak syms won't yet be marked as dynamic.  */
9491           else if (h->dynindx == -1
9492                    && !h->forced_local)
9493             {
9494               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9495                 return FALSE;
9496             }
9497         }
9498     }
9499   else if (h->type == STT_GNU_IFUNC)
9500     {
9501       if (!h->non_got_ref)
9502         eh->dyn_relocs = NULL;
9503     }
9504   else if (ELIMINATE_COPY_RELOCS)
9505     {
9506       /* For the non-shared case, discard space for relocs against
9507          symbols which turn out to need copy relocs or are not
9508          dynamic.  */
9509
9510       if (!h->non_got_ref
9511           && !h->def_regular)
9512         {
9513           /* Make sure this symbol is output as a dynamic symbol.
9514              Undefined weak syms won't yet be marked as dynamic.  */
9515           if (h->dynindx == -1
9516               && !h->forced_local)
9517             {
9518               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9519                 return FALSE;
9520             }
9521
9522           /* If that succeeded, we know we'll be keeping all the
9523              relocs.  */
9524           if (h->dynindx != -1)
9525             goto keep;
9526         }
9527
9528       eh->dyn_relocs = NULL;
9529
9530     keep: ;
9531     }
9532
9533   /* Finally, allocate space.  */
9534   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9535     {
9536       asection *sreloc = elf_section_data (p->sec)->sreloc;
9537       if (eh->elf.type == STT_GNU_IFUNC)
9538         sreloc = htab->elf.irelplt;
9539       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9540     }
9541
9542   return TRUE;
9543 }
9544
9545 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9546    to set up space for global entry stubs.  These are put in glink,
9547    after the branch table.  */
9548
9549 static bfd_boolean
9550 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9551 {
9552   struct bfd_link_info *info;
9553   struct ppc_link_hash_table *htab;
9554   struct plt_entry *pent;
9555   asection *s;
9556
9557   if (h->root.type == bfd_link_hash_indirect)
9558     return TRUE;
9559
9560   if (!h->pointer_equality_needed)
9561     return TRUE;
9562
9563   if (h->def_regular)
9564     return TRUE;
9565
9566   info = inf;
9567   htab = ppc_hash_table (info);
9568   if (htab == NULL)
9569     return FALSE;
9570
9571   s = htab->glink;
9572   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9573     if (pent->plt.offset != (bfd_vma) -1
9574         && pent->addend == 0)
9575       {
9576         /* For ELFv2, if this symbol is not defined in a regular file
9577            and we are not generating a shared library or pie, then we
9578            need to define the symbol in the executable on a call stub.
9579            This is to avoid text relocations.  */
9580         s->size = (s->size + 15) & -16;
9581         h->root.u.def.section = s;
9582         h->root.u.def.value = s->size;
9583         s->size += 16;
9584         break;
9585       }
9586   return TRUE;
9587 }
9588
9589 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9590    read-only sections.  */
9591
9592 static bfd_boolean
9593 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9594 {
9595   if (h->root.type == bfd_link_hash_indirect)
9596     return TRUE;
9597
9598   if (readonly_dynrelocs (h))
9599     {
9600       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9601
9602       /* Not an error, just cut short the traversal.  */
9603       return FALSE;
9604     }
9605   return TRUE;
9606 }
9607
9608 /* Set the sizes of the dynamic sections.  */
9609
9610 static bfd_boolean
9611 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9612                                  struct bfd_link_info *info)
9613 {
9614   struct ppc_link_hash_table *htab;
9615   bfd *dynobj;
9616   asection *s;
9617   bfd_boolean relocs;
9618   bfd *ibfd;
9619   struct got_entry *first_tlsld;
9620
9621   htab = ppc_hash_table (info);
9622   if (htab == NULL)
9623     return FALSE;
9624
9625   dynobj = htab->elf.dynobj;
9626   if (dynobj == NULL)
9627     abort ();
9628
9629   if (htab->elf.dynamic_sections_created)
9630     {
9631       /* Set the contents of the .interp section to the interpreter.  */
9632       if (info->executable)
9633         {
9634           s = bfd_get_linker_section (dynobj, ".interp");
9635           if (s == NULL)
9636             abort ();
9637           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9638           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9639         }
9640     }
9641
9642   /* Set up .got offsets for local syms, and space for local dynamic
9643      relocs.  */
9644   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9645     {
9646       struct got_entry **lgot_ents;
9647       struct got_entry **end_lgot_ents;
9648       struct plt_entry **local_plt;
9649       struct plt_entry **end_local_plt;
9650       unsigned char *lgot_masks;
9651       bfd_size_type locsymcount;
9652       Elf_Internal_Shdr *symtab_hdr;
9653
9654       if (!is_ppc64_elf (ibfd))
9655         continue;
9656
9657       for (s = ibfd->sections; s != NULL; s = s->next)
9658         {
9659           struct ppc_dyn_relocs *p;
9660
9661           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9662             {
9663               if (!bfd_is_abs_section (p->sec)
9664                   && bfd_is_abs_section (p->sec->output_section))
9665                 {
9666                   /* Input section has been discarded, either because
9667                      it is a copy of a linkonce section or due to
9668                      linker script /DISCARD/, so we'll be discarding
9669                      the relocs too.  */
9670                 }
9671               else if (p->count != 0)
9672                 {
9673                   asection *srel = elf_section_data (p->sec)->sreloc;
9674                   if (p->ifunc)
9675                     srel = htab->elf.irelplt;
9676                   srel->size += p->count * sizeof (Elf64_External_Rela);
9677                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9678                     info->flags |= DF_TEXTREL;
9679                 }
9680             }
9681         }
9682
9683       lgot_ents = elf_local_got_ents (ibfd);
9684       if (!lgot_ents)
9685         continue;
9686
9687       symtab_hdr = &elf_symtab_hdr (ibfd);
9688       locsymcount = symtab_hdr->sh_info;
9689       end_lgot_ents = lgot_ents + locsymcount;
9690       local_plt = (struct plt_entry **) end_lgot_ents;
9691       end_local_plt = local_plt + locsymcount;
9692       lgot_masks = (unsigned char *) end_local_plt;
9693       s = ppc64_elf_tdata (ibfd)->got;
9694       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9695         {
9696           struct got_entry **pent, *ent;
9697
9698           pent = lgot_ents;
9699           while ((ent = *pent) != NULL)
9700             if (ent->got.refcount > 0)
9701               {
9702                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9703                   {
9704                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9705                     *pent = ent->next;
9706                   }
9707                 else
9708                   {
9709                     unsigned int ent_size = 8;
9710                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9711
9712                     ent->got.offset = s->size;
9713                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9714                       {
9715                         ent_size *= 2;
9716                         rel_size *= 2;
9717                       }
9718                     s->size += ent_size;
9719                     if ((*lgot_masks & PLT_IFUNC) != 0)
9720                       {
9721                         htab->elf.irelplt->size += rel_size;
9722                         htab->got_reli_size += rel_size;
9723                       }
9724                     else if (info->shared)
9725                       {
9726                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9727                         srel->size += rel_size;
9728                       }
9729                     pent = &ent->next;
9730                   }
9731               }
9732             else
9733               *pent = ent->next;
9734         }
9735
9736       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9737       for (; local_plt < end_local_plt; ++local_plt)
9738         {
9739           struct plt_entry *ent;
9740
9741           for (ent = *local_plt; ent != NULL; ent = ent->next)
9742             if (ent->plt.refcount > 0)
9743               {
9744                 s = htab->elf.iplt;
9745                 ent->plt.offset = s->size;
9746                 s->size += PLT_ENTRY_SIZE (htab);
9747
9748                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9749               }
9750             else
9751               ent->plt.offset = (bfd_vma) -1;
9752         }
9753     }
9754
9755   /* Allocate global sym .plt and .got entries, and space for global
9756      sym dynamic relocs.  */
9757   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9758   /* Stash the end of glink branch table.  */
9759   if (htab->glink != NULL)
9760     htab->glink->rawsize = htab->glink->size;
9761
9762   if (!htab->opd_abi && !info->shared)
9763     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9764
9765   first_tlsld = NULL;
9766   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9767     {
9768       struct got_entry *ent;
9769
9770       if (!is_ppc64_elf (ibfd))
9771         continue;
9772
9773       ent = ppc64_tlsld_got (ibfd);
9774       if (ent->got.refcount > 0)
9775         {
9776           if (!htab->do_multi_toc && first_tlsld != NULL)
9777             {
9778               ent->is_indirect = TRUE;
9779               ent->got.ent = first_tlsld;
9780             }
9781           else
9782             {
9783               if (first_tlsld == NULL)
9784                 first_tlsld = ent;
9785               s = ppc64_elf_tdata (ibfd)->got;
9786               ent->got.offset = s->size;
9787               ent->owner = ibfd;
9788               s->size += 16;
9789               if (info->shared)
9790                 {
9791                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9792                   srel->size += sizeof (Elf64_External_Rela);
9793                 }
9794             }
9795         }
9796       else
9797         ent->got.offset = (bfd_vma) -1;
9798     }
9799
9800   /* We now have determined the sizes of the various dynamic sections.
9801      Allocate memory for them.  */
9802   relocs = FALSE;
9803   for (s = dynobj->sections; s != NULL; s = s->next)
9804     {
9805       if ((s->flags & SEC_LINKER_CREATED) == 0)
9806         continue;
9807
9808       if (s == htab->brlt || s == htab->relbrlt)
9809         /* These haven't been allocated yet;  don't strip.  */
9810         continue;
9811       else if (s == htab->elf.sgot
9812                || s == htab->elf.splt
9813                || s == htab->elf.iplt
9814                || s == htab->glink
9815                || s == htab->dynbss)
9816         {
9817           /* Strip this section if we don't need it; see the
9818              comment below.  */
9819         }
9820       else if (s == htab->glink_eh_frame)
9821         {
9822           if (!bfd_is_abs_section (s->output_section))
9823             /* Not sized yet.  */
9824             continue;
9825         }
9826       else if (CONST_STRNEQ (s->name, ".rela"))
9827         {
9828           if (s->size != 0)
9829             {
9830               if (s != htab->elf.srelplt)
9831                 relocs = TRUE;
9832
9833               /* We use the reloc_count field as a counter if we need
9834                  to copy relocs into the output file.  */
9835               s->reloc_count = 0;
9836             }
9837         }
9838       else
9839         {
9840           /* It's not one of our sections, so don't allocate space.  */
9841           continue;
9842         }
9843
9844       if (s->size == 0)
9845         {
9846           /* If we don't need this section, strip it from the
9847              output file.  This is mostly to handle .rela.bss and
9848              .rela.plt.  We must create both sections in
9849              create_dynamic_sections, because they must be created
9850              before the linker maps input sections to output
9851              sections.  The linker does that before
9852              adjust_dynamic_symbol is called, and it is that
9853              function which decides whether anything needs to go
9854              into these sections.  */
9855           s->flags |= SEC_EXCLUDE;
9856           continue;
9857         }
9858
9859       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9860         continue;
9861
9862       /* Allocate memory for the section contents.  We use bfd_zalloc
9863          here in case unused entries are not reclaimed before the
9864          section's contents are written out.  This should not happen,
9865          but this way if it does we get a R_PPC64_NONE reloc in .rela
9866          sections instead of garbage.
9867          We also rely on the section contents being zero when writing
9868          the GOT.  */
9869       s->contents = bfd_zalloc (dynobj, s->size);
9870       if (s->contents == NULL)
9871         return FALSE;
9872     }
9873
9874   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9875     {
9876       if (!is_ppc64_elf (ibfd))
9877         continue;
9878
9879       s = ppc64_elf_tdata (ibfd)->got;
9880       if (s != NULL && s != htab->elf.sgot)
9881         {
9882           if (s->size == 0)
9883             s->flags |= SEC_EXCLUDE;
9884           else
9885             {
9886               s->contents = bfd_zalloc (ibfd, s->size);
9887               if (s->contents == NULL)
9888                 return FALSE;
9889             }
9890         }
9891       s = ppc64_elf_tdata (ibfd)->relgot;
9892       if (s != NULL)
9893         {
9894           if (s->size == 0)
9895             s->flags |= SEC_EXCLUDE;
9896           else
9897             {
9898               s->contents = bfd_zalloc (ibfd, s->size);
9899               if (s->contents == NULL)
9900                 return FALSE;
9901               relocs = TRUE;
9902               s->reloc_count = 0;
9903             }
9904         }
9905     }
9906
9907   if (htab->elf.dynamic_sections_created)
9908     {
9909       bfd_boolean tls_opt;
9910
9911       /* Add some entries to the .dynamic section.  We fill in the
9912          values later, in ppc64_elf_finish_dynamic_sections, but we
9913          must add the entries now so that we get the correct size for
9914          the .dynamic section.  The DT_DEBUG entry is filled in by the
9915          dynamic linker and used by the debugger.  */
9916 #define add_dynamic_entry(TAG, VAL) \
9917   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9918
9919       if (info->executable)
9920         {
9921           if (!add_dynamic_entry (DT_DEBUG, 0))
9922             return FALSE;
9923         }
9924
9925       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9926         {
9927           if (!add_dynamic_entry (DT_PLTGOT, 0)
9928               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9929               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9930               || !add_dynamic_entry (DT_JMPREL, 0)
9931               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9932             return FALSE;
9933         }
9934
9935       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9936         {
9937           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9938               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9939             return FALSE;
9940         }
9941
9942       tls_opt = (!htab->params->no_tls_get_addr_opt
9943                  && htab->tls_get_addr_fd != NULL
9944                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9945       if (tls_opt || !htab->opd_abi)
9946         {
9947           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9948             return FALSE;
9949         }
9950
9951       if (relocs)
9952         {
9953           if (!add_dynamic_entry (DT_RELA, 0)
9954               || !add_dynamic_entry (DT_RELASZ, 0)
9955               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9956             return FALSE;
9957
9958           /* If any dynamic relocs apply to a read-only section,
9959              then we need a DT_TEXTREL entry.  */
9960           if ((info->flags & DF_TEXTREL) == 0)
9961             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9962
9963           if ((info->flags & DF_TEXTREL) != 0)
9964             {
9965               if (!add_dynamic_entry (DT_TEXTREL, 0))
9966                 return FALSE;
9967             }
9968         }
9969     }
9970 #undef add_dynamic_entry
9971
9972   return TRUE;
9973 }
9974
9975 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9976
9977 static bfd_boolean
9978 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9979 {
9980   if (h->plt.plist != NULL
9981       && !h->def_regular
9982       && !h->pointer_equality_needed)
9983     return FALSE;
9984
9985   return _bfd_elf_hash_symbol (h);
9986 }
9987
9988 /* Determine the type of stub needed, if any, for a call.  */
9989
9990 static inline enum ppc_stub_type
9991 ppc_type_of_stub (asection *input_sec,
9992                   const Elf_Internal_Rela *rel,
9993                   struct ppc_link_hash_entry **hash,
9994                   struct plt_entry **plt_ent,
9995                   bfd_vma destination,
9996                   unsigned long local_off)
9997 {
9998   struct ppc_link_hash_entry *h = *hash;
9999   bfd_vma location;
10000   bfd_vma branch_offset;
10001   bfd_vma max_branch_offset;
10002   enum elf_ppc64_reloc_type r_type;
10003
10004   if (h != NULL)
10005     {
10006       struct plt_entry *ent;
10007       struct ppc_link_hash_entry *fdh = h;
10008       if (h->oh != NULL
10009           && h->oh->is_func_descriptor)
10010         {
10011           fdh = ppc_follow_link (h->oh);
10012           *hash = fdh;
10013         }
10014
10015       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10016         if (ent->addend == rel->r_addend
10017             && ent->plt.offset != (bfd_vma) -1)
10018           {
10019             *plt_ent = ent;
10020             return ppc_stub_plt_call;
10021           }
10022
10023       /* Here, we know we don't have a plt entry.  If we don't have a
10024          either a defined function descriptor or a defined entry symbol
10025          in a regular object file, then it is pointless trying to make
10026          any other type of stub.  */
10027       if (!is_static_defined (&fdh->elf)
10028           && !is_static_defined (&h->elf))
10029         return ppc_stub_none;
10030     }
10031   else if (elf_local_got_ents (input_sec->owner) != NULL)
10032     {
10033       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10034       struct plt_entry **local_plt = (struct plt_entry **)
10035         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10036       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10037
10038       if (local_plt[r_symndx] != NULL)
10039         {
10040           struct plt_entry *ent;
10041
10042           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10043             if (ent->addend == rel->r_addend
10044                 && ent->plt.offset != (bfd_vma) -1)
10045               {
10046                 *plt_ent = ent;
10047                 return ppc_stub_plt_call;
10048               }
10049         }
10050     }
10051
10052   /* Determine where the call point is.  */
10053   location = (input_sec->output_offset
10054               + input_sec->output_section->vma
10055               + rel->r_offset);
10056
10057   branch_offset = destination - location;
10058   r_type = ELF64_R_TYPE (rel->r_info);
10059
10060   /* Determine if a long branch stub is needed.  */
10061   max_branch_offset = 1 << 25;
10062   if (r_type != R_PPC64_REL24)
10063     max_branch_offset = 1 << 15;
10064
10065   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10066     /* We need a stub.  Figure out whether a long_branch or plt_branch
10067        is needed later.  */
10068     return ppc_stub_long_branch;
10069
10070   return ppc_stub_none;
10071 }
10072
10073 /* With power7 weakly ordered memory model, it is possible for ld.so
10074    to update a plt entry in one thread and have another thread see a
10075    stale zero toc entry.  To avoid this we need some sort of acquire
10076    barrier in the call stub.  One solution is to make the load of the
10077    toc word seem to appear to depend on the load of the function entry
10078    word.  Another solution is to test for r2 being zero, and branch to
10079    the appropriate glink entry if so.
10080
10081    .    fake dep barrier        compare
10082    .    ld 12,xxx(2)            ld 12,xxx(2)
10083    .    mtctr 12                mtctr 12
10084    .    xor 11,12,12            ld 2,xxx+8(2)
10085    .    add 2,2,11              cmpldi 2,0
10086    .    ld 2,xxx+8(2)           bnectr+
10087    .    bctr                    b <glink_entry>
10088
10089    The solution involving the compare turns out to be faster, so
10090    that's what we use unless the branch won't reach.  */
10091
10092 #define ALWAYS_USE_FAKE_DEP 0
10093 #define ALWAYS_EMIT_R2SAVE 0
10094
10095 #define PPC_LO(v) ((v) & 0xffff)
10096 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10097 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10098
10099 static inline unsigned int
10100 plt_stub_size (struct ppc_link_hash_table *htab,
10101                struct ppc_stub_hash_entry *stub_entry,
10102                bfd_vma off)
10103 {
10104   unsigned size = 12;
10105
10106   if (ALWAYS_EMIT_R2SAVE
10107       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10108     size += 4;
10109   if (PPC_HA (off) != 0)
10110     size += 4;
10111   if (htab->opd_abi)
10112     {
10113       size += 4;
10114       if (htab->params->plt_static_chain)
10115         size += 4;
10116       if (htab->params->plt_thread_safe)
10117         size += 8;
10118       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10119         size += 4;
10120     }
10121   if (stub_entry->h != NULL
10122       && (stub_entry->h == htab->tls_get_addr_fd
10123           || stub_entry->h == htab->tls_get_addr)
10124       && !htab->params->no_tls_get_addr_opt)
10125     size += 13 * 4;
10126   return size;
10127 }
10128
10129 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10130    then return the padding needed to do so.  */
10131 static inline unsigned int
10132 plt_stub_pad (struct ppc_link_hash_table *htab,
10133               struct ppc_stub_hash_entry *stub_entry,
10134               bfd_vma plt_off)
10135 {
10136   int stub_align = 1 << htab->params->plt_stub_align;
10137   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10138   bfd_vma stub_off = stub_entry->stub_sec->size;
10139
10140   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10141       > (stub_size & -stub_align))
10142     return stub_align - (stub_off & (stub_align - 1));
10143   return 0;
10144 }
10145
10146 /* Build a .plt call stub.  */
10147
10148 static inline bfd_byte *
10149 build_plt_stub (struct ppc_link_hash_table *htab,
10150                 struct ppc_stub_hash_entry *stub_entry,
10151                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10152 {
10153   bfd *obfd = htab->params->stub_bfd;
10154   bfd_boolean plt_load_toc = htab->opd_abi;
10155   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10156   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10157   bfd_boolean use_fake_dep = plt_thread_safe;
10158   bfd_vma cmp_branch_off = 0;
10159
10160   if (!ALWAYS_USE_FAKE_DEP
10161       && plt_load_toc
10162       && plt_thread_safe
10163       && !(stub_entry->h != NULL
10164            && (stub_entry->h == htab->tls_get_addr_fd
10165                || stub_entry->h == htab->tls_get_addr)
10166            && !htab->params->no_tls_get_addr_opt))
10167     {
10168       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10169       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10170                           / PLT_ENTRY_SIZE (htab));
10171       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10172       bfd_vma to, from;
10173
10174       if (pltindex > 32768)
10175         glinkoff += (pltindex - 32768) * 4;
10176       to = (glinkoff
10177             + htab->glink->output_offset
10178             + htab->glink->output_section->vma);
10179       from = (p - stub_entry->stub_sec->contents
10180               + 4 * (ALWAYS_EMIT_R2SAVE
10181                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10182               + 4 * (PPC_HA (offset) != 0)
10183               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10184                      != PPC_HA (offset))
10185               + 4 * (plt_static_chain != 0)
10186               + 20
10187               + stub_entry->stub_sec->output_offset
10188               + stub_entry->stub_sec->output_section->vma);
10189       cmp_branch_off = to - from;
10190       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10191     }
10192
10193   if (PPC_HA (offset) != 0)
10194     {
10195       if (r != NULL)
10196         {
10197           if (ALWAYS_EMIT_R2SAVE
10198               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10199             r[0].r_offset += 4;
10200           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10201           r[1].r_offset = r[0].r_offset + 4;
10202           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10203           r[1].r_addend = r[0].r_addend;
10204           if (plt_load_toc)
10205             {
10206               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10207                 {
10208                   r[2].r_offset = r[1].r_offset + 4;
10209                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10210                   r[2].r_addend = r[0].r_addend;
10211                 }
10212               else
10213                 {
10214                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10215                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10216                   r[2].r_addend = r[0].r_addend + 8;
10217                   if (plt_static_chain)
10218                     {
10219                       r[3].r_offset = r[2].r_offset + 4;
10220                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10221                       r[3].r_addend = r[0].r_addend + 16;
10222                     }
10223                 }
10224             }
10225         }
10226       if (ALWAYS_EMIT_R2SAVE
10227           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10228         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10229       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10230       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10231       if (plt_load_toc
10232           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10233         {
10234           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10235           offset = 0;
10236         }
10237       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10238       if (plt_load_toc)
10239         {
10240           if (use_fake_dep)
10241             {
10242               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10243               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10244             }
10245           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10246           if (plt_static_chain)
10247             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10248         }
10249     }
10250   else
10251     {
10252       if (r != NULL)
10253         {
10254           if (ALWAYS_EMIT_R2SAVE
10255               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10256             r[0].r_offset += 4;
10257           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10258           if (plt_load_toc)
10259             {
10260               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10261                 {
10262                   r[1].r_offset = r[0].r_offset + 4;
10263                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10264                   r[1].r_addend = r[0].r_addend;
10265                 }
10266               else
10267                 {
10268                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10269                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10270                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10271                   if (plt_static_chain)
10272                     {
10273                       r[2].r_offset = r[1].r_offset + 4;
10274                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10275                       r[2].r_addend = r[0].r_addend + 8;
10276                     }
10277                 }
10278             }
10279         }
10280       if (ALWAYS_EMIT_R2SAVE
10281           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10282         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10283       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10284       if (plt_load_toc
10285           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10286         {
10287           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10288           offset = 0;
10289         }
10290       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10291       if (plt_load_toc)
10292         {
10293           if (use_fake_dep)
10294             {
10295               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10296               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10297             }
10298           if (plt_static_chain)
10299             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10300           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10301         }
10302     }
10303   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10304     {
10305       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10306       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10307       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10308     }
10309   else
10310     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10311   return p;
10312 }
10313
10314 /* Build a special .plt call stub for __tls_get_addr.  */
10315
10316 #define LD_R11_0R3      0xe9630000
10317 #define LD_R12_0R3      0xe9830000
10318 #define MR_R0_R3        0x7c601b78
10319 #define CMPDI_R11_0     0x2c2b0000
10320 #define ADD_R3_R12_R13  0x7c6c6a14
10321 #define BEQLR           0x4d820020
10322 #define MR_R3_R0        0x7c030378
10323 #define STD_R11_0R1     0xf9610000
10324 #define BCTRL           0x4e800421
10325 #define LD_R11_0R1      0xe9610000
10326 #define MTLR_R11        0x7d6803a6
10327
10328 static inline bfd_byte *
10329 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10330                          struct ppc_stub_hash_entry *stub_entry,
10331                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10332 {
10333   bfd *obfd = htab->params->stub_bfd;
10334
10335   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10336   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10337   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10338   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10339   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10340   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10341   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10342   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10343   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10344
10345   if (r != NULL)
10346     r[0].r_offset += 9 * 4;
10347   p = build_plt_stub (htab, stub_entry, p, offset, r);
10348   bfd_put_32 (obfd, BCTRL, p - 4);
10349
10350   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10351   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10352   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10353   bfd_put_32 (obfd, BLR, p),                    p += 4;
10354
10355   return p;
10356 }
10357
10358 static Elf_Internal_Rela *
10359 get_relocs (asection *sec, int count)
10360 {
10361   Elf_Internal_Rela *relocs;
10362   struct bfd_elf_section_data *elfsec_data;
10363
10364   elfsec_data = elf_section_data (sec);
10365   relocs = elfsec_data->relocs;
10366   if (relocs == NULL)
10367     {
10368       bfd_size_type relsize;
10369       relsize = sec->reloc_count * sizeof (*relocs);
10370       relocs = bfd_alloc (sec->owner, relsize);
10371       if (relocs == NULL)
10372         return NULL;
10373       elfsec_data->relocs = relocs;
10374       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10375                                           sizeof (Elf_Internal_Shdr));
10376       if (elfsec_data->rela.hdr == NULL)
10377         return NULL;
10378       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10379                                         * sizeof (Elf64_External_Rela));
10380       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10381       sec->reloc_count = 0;
10382     }
10383   relocs += sec->reloc_count;
10384   sec->reloc_count += count;
10385   return relocs;
10386 }
10387
10388 static bfd_vma
10389 get_r2off (struct bfd_link_info *info,
10390            struct ppc_stub_hash_entry *stub_entry)
10391 {
10392   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10393   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10394
10395   if (r2off == 0)
10396     {
10397       /* Support linking -R objects.  Get the toc pointer from the
10398          opd entry.  */
10399       char buf[8];
10400       if (!htab->opd_abi)
10401         return r2off;
10402       asection *opd = stub_entry->h->elf.root.u.def.section;
10403       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10404
10405       if (strcmp (opd->name, ".opd") != 0
10406           || opd->reloc_count != 0)
10407         {
10408           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10409                                   stub_entry->h->elf.root.root.string);
10410           bfd_set_error (bfd_error_bad_value);
10411           return 0;
10412         }
10413       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10414         return 0;
10415       r2off = bfd_get_64 (opd->owner, buf);
10416       r2off -= elf_gp (info->output_bfd);
10417     }
10418   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10419   return r2off;
10420 }
10421
10422 static bfd_boolean
10423 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10424 {
10425   struct ppc_stub_hash_entry *stub_entry;
10426   struct ppc_branch_hash_entry *br_entry;
10427   struct bfd_link_info *info;
10428   struct ppc_link_hash_table *htab;
10429   bfd_byte *loc;
10430   bfd_byte *p;
10431   bfd_vma dest, off;
10432   int size;
10433   Elf_Internal_Rela *r;
10434   asection *plt;
10435
10436   /* Massage our args to the form they really have.  */
10437   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10438   info = in_arg;
10439
10440   htab = ppc_hash_table (info);
10441   if (htab == NULL)
10442     return FALSE;
10443
10444   /* Make a note of the offset within the stubs for this entry.  */
10445   stub_entry->stub_offset = stub_entry->stub_sec->size;
10446   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10447
10448   htab->stub_count[stub_entry->stub_type - 1] += 1;
10449   switch (stub_entry->stub_type)
10450     {
10451     case ppc_stub_long_branch:
10452     case ppc_stub_long_branch_r2off:
10453       /* Branches are relative.  This is where we are going to.  */
10454       dest = (stub_entry->target_value
10455               + stub_entry->target_section->output_offset
10456               + stub_entry->target_section->output_section->vma);
10457       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10458       off = dest;
10459
10460       /* And this is where we are coming from.  */
10461       off -= (stub_entry->stub_offset
10462               + stub_entry->stub_sec->output_offset
10463               + stub_entry->stub_sec->output_section->vma);
10464
10465       size = 4;
10466       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10467         {
10468           bfd_vma r2off = get_r2off (info, stub_entry);
10469
10470           if (r2off == 0)
10471             {
10472               htab->stub_error = TRUE;
10473               return FALSE;
10474             }
10475           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10476           loc += 4;
10477           size = 12;
10478           if (PPC_HA (r2off) != 0)
10479             {
10480               size = 16;
10481               bfd_put_32 (htab->params->stub_bfd,
10482                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10483               loc += 4;
10484             }
10485           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10486           loc += 4;
10487           off -= size - 4;
10488         }
10489       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10490
10491       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10492         {
10493           info->callbacks->einfo
10494             (_("%P: long branch stub `%s' offset overflow\n"),
10495              stub_entry->root.string);
10496           htab->stub_error = TRUE;
10497           return FALSE;
10498         }
10499
10500       if (info->emitrelocations)
10501         {
10502           r = get_relocs (stub_entry->stub_sec, 1);
10503           if (r == NULL)
10504             return FALSE;
10505           r->r_offset = loc - stub_entry->stub_sec->contents;
10506           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10507           r->r_addend = dest;
10508           if (stub_entry->h != NULL)
10509             {
10510               struct elf_link_hash_entry **hashes;
10511               unsigned long symndx;
10512               struct ppc_link_hash_entry *h;
10513
10514               hashes = elf_sym_hashes (htab->params->stub_bfd);
10515               if (hashes == NULL)
10516                 {
10517                   bfd_size_type hsize;
10518
10519                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10520                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10521                   if (hashes == NULL)
10522                     return FALSE;
10523                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10524                   htab->stub_globals = 1;
10525                 }
10526               symndx = htab->stub_globals++;
10527               h = stub_entry->h;
10528               hashes[symndx] = &h->elf;
10529               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10530               if (h->oh != NULL && h->oh->is_func)
10531                 h = ppc_follow_link (h->oh);
10532               if (h->elf.root.u.def.section != stub_entry->target_section)
10533                 /* H is an opd symbol.  The addend must be zero.  */
10534                 r->r_addend = 0;
10535               else
10536                 {
10537                   off = (h->elf.root.u.def.value
10538                          + h->elf.root.u.def.section->output_offset
10539                          + h->elf.root.u.def.section->output_section->vma);
10540                   r->r_addend -= off;
10541                 }
10542             }
10543         }
10544       break;
10545
10546     case ppc_stub_plt_branch:
10547     case ppc_stub_plt_branch_r2off:
10548       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10549                                          stub_entry->root.string + 9,
10550                                          FALSE, FALSE);
10551       if (br_entry == NULL)
10552         {
10553           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10554                                   stub_entry->root.string);
10555           htab->stub_error = TRUE;
10556           return FALSE;
10557         }
10558
10559       dest = (stub_entry->target_value
10560               + stub_entry->target_section->output_offset
10561               + stub_entry->target_section->output_section->vma);
10562       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10563         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10564
10565       bfd_put_64 (htab->brlt->owner, dest,
10566                   htab->brlt->contents + br_entry->offset);
10567
10568       if (br_entry->iter == htab->stub_iteration)
10569         {
10570           br_entry->iter = 0;
10571
10572           if (htab->relbrlt != NULL)
10573             {
10574               /* Create a reloc for the branch lookup table entry.  */
10575               Elf_Internal_Rela rela;
10576               bfd_byte *rl;
10577
10578               rela.r_offset = (br_entry->offset
10579                                + htab->brlt->output_offset
10580                                + htab->brlt->output_section->vma);
10581               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10582               rela.r_addend = dest;
10583
10584               rl = htab->relbrlt->contents;
10585               rl += (htab->relbrlt->reloc_count++
10586                      * sizeof (Elf64_External_Rela));
10587               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10588             }
10589           else if (info->emitrelocations)
10590             {
10591               r = get_relocs (htab->brlt, 1);
10592               if (r == NULL)
10593                 return FALSE;
10594               /* brlt, being SEC_LINKER_CREATED does not go through the
10595                  normal reloc processing.  Symbols and offsets are not
10596                  translated from input file to output file form, so
10597                  set up the offset per the output file.  */
10598               r->r_offset = (br_entry->offset
10599                              + htab->brlt->output_offset
10600                              + htab->brlt->output_section->vma);
10601               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10602               r->r_addend = dest;
10603             }
10604         }
10605
10606       dest = (br_entry->offset
10607               + htab->brlt->output_offset
10608               + htab->brlt->output_section->vma);
10609
10610       off = (dest
10611              - elf_gp (htab->brlt->output_section->owner)
10612              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10613
10614       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10615         {
10616           info->callbacks->einfo
10617             (_("%P: linkage table error against `%T'\n"),
10618              stub_entry->root.string);
10619           bfd_set_error (bfd_error_bad_value);
10620           htab->stub_error = TRUE;
10621           return FALSE;
10622         }
10623
10624       if (info->emitrelocations)
10625         {
10626           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10627           if (r == NULL)
10628             return FALSE;
10629           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10630           if (bfd_big_endian (info->output_bfd))
10631             r[0].r_offset += 2;
10632           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10633             r[0].r_offset += 4;
10634           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10635           r[0].r_addend = dest;
10636           if (PPC_HA (off) != 0)
10637             {
10638               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10639               r[1].r_offset = r[0].r_offset + 4;
10640               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10641               r[1].r_addend = r[0].r_addend;
10642             }
10643         }
10644
10645       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10646         {
10647           if (PPC_HA (off) != 0)
10648             {
10649               size = 16;
10650               bfd_put_32 (htab->params->stub_bfd,
10651                           ADDIS_R11_R2 | PPC_HA (off), loc);
10652               loc += 4;
10653               bfd_put_32 (htab->params->stub_bfd,
10654                           LD_R12_0R11 | PPC_LO (off), loc);
10655             }
10656           else
10657             {
10658               size = 12;
10659               bfd_put_32 (htab->params->stub_bfd,
10660                           LD_R12_0R2 | PPC_LO (off), loc);
10661             }
10662         }
10663       else
10664         {
10665           bfd_vma r2off = get_r2off (info, stub_entry);
10666
10667           if (r2off == 0 && htab->opd_abi)
10668             {
10669               htab->stub_error = TRUE;
10670               return FALSE;
10671             }
10672
10673           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10674           loc += 4;
10675           size = 16;
10676           if (PPC_HA (off) != 0)
10677             {
10678               size += 4;
10679               bfd_put_32 (htab->params->stub_bfd,
10680                           ADDIS_R11_R2 | PPC_HA (off), loc);
10681               loc += 4;
10682               bfd_put_32 (htab->params->stub_bfd,
10683                           LD_R12_0R11 | PPC_LO (off), loc);
10684             }
10685           else
10686             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10687
10688           if (PPC_HA (r2off) != 0)
10689             {
10690               size += 4;
10691               loc += 4;
10692               bfd_put_32 (htab->params->stub_bfd,
10693                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10694             }
10695           if (PPC_LO (r2off) != 0)
10696             {
10697               size += 4;
10698               loc += 4;
10699               bfd_put_32 (htab->params->stub_bfd,
10700                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10701             }
10702         }
10703       loc += 4;
10704       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10705       loc += 4;
10706       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10707       break;
10708
10709     case ppc_stub_plt_call:
10710     case ppc_stub_plt_call_r2save:
10711       if (stub_entry->h != NULL
10712           && stub_entry->h->is_func_descriptor
10713           && stub_entry->h->oh != NULL)
10714         {
10715           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10716
10717           /* If the old-ABI "dot-symbol" is undefined make it weak so
10718              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10719              FIXME: We used to define the symbol on one of the call
10720              stubs instead, which is why we test symbol section id
10721              against htab->top_id in various places.  Likely all
10722              these checks could now disappear.  */
10723           if (fh->elf.root.type == bfd_link_hash_undefined)
10724             fh->elf.root.type = bfd_link_hash_undefweak;
10725           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10726           fh->was_undefined = 0;
10727         }
10728
10729       /* Now build the stub.  */
10730       dest = stub_entry->plt_ent->plt.offset & ~1;
10731       if (dest >= (bfd_vma) -2)
10732         abort ();
10733
10734       plt = htab->elf.splt;
10735       if (!htab->elf.dynamic_sections_created
10736           || stub_entry->h == NULL
10737           || stub_entry->h->elf.dynindx == -1)
10738         plt = htab->elf.iplt;
10739
10740       dest += plt->output_offset + plt->output_section->vma;
10741
10742       if (stub_entry->h == NULL
10743           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10744         {
10745           Elf_Internal_Rela rela;
10746           bfd_byte *rl;
10747
10748           rela.r_offset = dest;
10749           if (htab->opd_abi)
10750             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10751           else
10752             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10753           rela.r_addend = (stub_entry->target_value
10754                            + stub_entry->target_section->output_offset
10755                            + stub_entry->target_section->output_section->vma);
10756
10757           rl = (htab->elf.irelplt->contents
10758                 + (htab->elf.irelplt->reloc_count++
10759                    * sizeof (Elf64_External_Rela)));
10760           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10761           stub_entry->plt_ent->plt.offset |= 1;
10762         }
10763
10764       off = (dest
10765              - elf_gp (plt->output_section->owner)
10766              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10767
10768       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10769         {
10770           info->callbacks->einfo
10771             (_("%P: linkage table error against `%T'\n"),
10772              stub_entry->h != NULL
10773              ? stub_entry->h->elf.root.root.string
10774              : "<local sym>");
10775           bfd_set_error (bfd_error_bad_value);
10776           htab->stub_error = TRUE;
10777           return FALSE;
10778         }
10779
10780       if (htab->params->plt_stub_align != 0)
10781         {
10782           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10783
10784           stub_entry->stub_sec->size += pad;
10785           stub_entry->stub_offset = stub_entry->stub_sec->size;
10786           loc += pad;
10787         }
10788
10789       r = NULL;
10790       if (info->emitrelocations)
10791         {
10792           r = get_relocs (stub_entry->stub_sec,
10793                           ((PPC_HA (off) != 0)
10794                            + (htab->opd_abi
10795                               ? 2 + (htab->params->plt_static_chain
10796                                      && PPC_HA (off + 16) == PPC_HA (off))
10797                               : 1)));
10798           if (r == NULL)
10799             return FALSE;
10800           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10801           if (bfd_big_endian (info->output_bfd))
10802             r[0].r_offset += 2;
10803           r[0].r_addend = dest;
10804         }
10805       if (stub_entry->h != NULL
10806           && (stub_entry->h == htab->tls_get_addr_fd
10807               || stub_entry->h == htab->tls_get_addr)
10808           && !htab->params->no_tls_get_addr_opt)
10809         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10810       else
10811         p = build_plt_stub (htab, stub_entry, loc, off, r);
10812       size = p - loc;
10813       break;
10814
10815     default:
10816       BFD_FAIL ();
10817       return FALSE;
10818     }
10819
10820   stub_entry->stub_sec->size += size;
10821
10822   if (htab->params->emit_stub_syms)
10823     {
10824       struct elf_link_hash_entry *h;
10825       size_t len1, len2;
10826       char *name;
10827       const char *const stub_str[] = { "long_branch",
10828                                        "long_branch_r2off",
10829                                        "plt_branch",
10830                                        "plt_branch_r2off",
10831                                        "plt_call",
10832                                        "plt_call" };
10833
10834       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10835       len2 = strlen (stub_entry->root.string);
10836       name = bfd_malloc (len1 + len2 + 2);
10837       if (name == NULL)
10838         return FALSE;
10839       memcpy (name, stub_entry->root.string, 9);
10840       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10841       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10842       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10843       if (h == NULL)
10844         return FALSE;
10845       if (h->root.type == bfd_link_hash_new)
10846         {
10847           h->root.type = bfd_link_hash_defined;
10848           h->root.u.def.section = stub_entry->stub_sec;
10849           h->root.u.def.value = stub_entry->stub_offset;
10850           h->ref_regular = 1;
10851           h->def_regular = 1;
10852           h->ref_regular_nonweak = 1;
10853           h->forced_local = 1;
10854           h->non_elf = 0;
10855         }
10856     }
10857
10858   return TRUE;
10859 }
10860
10861 /* As above, but don't actually build the stub.  Just bump offset so
10862    we know stub section sizes, and select plt_branch stubs where
10863    long_branch stubs won't do.  */
10864
10865 static bfd_boolean
10866 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10867 {
10868   struct ppc_stub_hash_entry *stub_entry;
10869   struct bfd_link_info *info;
10870   struct ppc_link_hash_table *htab;
10871   bfd_vma off;
10872   int size;
10873
10874   /* Massage our args to the form they really have.  */
10875   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10876   info = in_arg;
10877
10878   htab = ppc_hash_table (info);
10879   if (htab == NULL)
10880     return FALSE;
10881
10882   if (stub_entry->stub_type == ppc_stub_plt_call
10883       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10884     {
10885       asection *plt;
10886       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10887       if (off >= (bfd_vma) -2)
10888         abort ();
10889       plt = htab->elf.splt;
10890       if (!htab->elf.dynamic_sections_created
10891           || stub_entry->h == NULL
10892           || stub_entry->h->elf.dynindx == -1)
10893         plt = htab->elf.iplt;
10894       off += (plt->output_offset
10895               + plt->output_section->vma
10896               - elf_gp (plt->output_section->owner)
10897               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10898
10899       size = plt_stub_size (htab, stub_entry, off);
10900       if (htab->params->plt_stub_align)
10901         size += plt_stub_pad (htab, stub_entry, off);
10902       if (info->emitrelocations)
10903         {
10904           stub_entry->stub_sec->reloc_count
10905             += ((PPC_HA (off) != 0)
10906                 + (htab->opd_abi
10907                    ? 2 + (htab->params->plt_static_chain
10908                           && PPC_HA (off + 16) == PPC_HA (off))
10909                    : 1));
10910           stub_entry->stub_sec->flags |= SEC_RELOC;
10911         }
10912     }
10913   else
10914     {
10915       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10916          variants.  */
10917       bfd_vma r2off = 0;
10918       bfd_vma local_off = 0;
10919
10920       off = (stub_entry->target_value
10921              + stub_entry->target_section->output_offset
10922              + stub_entry->target_section->output_section->vma);
10923       off -= (stub_entry->stub_sec->size
10924               + stub_entry->stub_sec->output_offset
10925               + stub_entry->stub_sec->output_section->vma);
10926
10927       /* Reset the stub type from the plt variant in case we now
10928          can reach with a shorter stub.  */
10929       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10930         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10931
10932       size = 4;
10933       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10934         {
10935           r2off = get_r2off (info, stub_entry);
10936           if (r2off == 0 && htab->opd_abi)
10937             {
10938               htab->stub_error = TRUE;
10939               return FALSE;
10940             }
10941           size = 12;
10942           if (PPC_HA (r2off) != 0)
10943             size = 16;
10944           off -= size - 4;
10945         }
10946
10947       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10948
10949       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10950          Do the same for -R objects without function descriptors.  */
10951       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10952           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10953               && r2off == 0))
10954         {
10955           struct ppc_branch_hash_entry *br_entry;
10956
10957           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10958                                              stub_entry->root.string + 9,
10959                                              TRUE, FALSE);
10960           if (br_entry == NULL)
10961             {
10962               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10963                                       stub_entry->root.string);
10964               htab->stub_error = TRUE;
10965               return FALSE;
10966             }
10967
10968           if (br_entry->iter != htab->stub_iteration)
10969             {
10970               br_entry->iter = htab->stub_iteration;
10971               br_entry->offset = htab->brlt->size;
10972               htab->brlt->size += 8;
10973
10974               if (htab->relbrlt != NULL)
10975                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10976               else if (info->emitrelocations)
10977                 {
10978                   htab->brlt->reloc_count += 1;
10979                   htab->brlt->flags |= SEC_RELOC;
10980                 }
10981             }
10982
10983           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10984           off = (br_entry->offset
10985                  + htab->brlt->output_offset
10986                  + htab->brlt->output_section->vma
10987                  - elf_gp (htab->brlt->output_section->owner)
10988                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10989
10990           if (info->emitrelocations)
10991             {
10992               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10993               stub_entry->stub_sec->flags |= SEC_RELOC;
10994             }
10995
10996           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10997             {
10998               size = 12;
10999               if (PPC_HA (off) != 0)
11000                 size = 16;
11001             }
11002           else
11003             {
11004               size = 16;
11005               if (PPC_HA (off) != 0)
11006                 size += 4;
11007
11008               if (PPC_HA (r2off) != 0)
11009                 size += 4;
11010               if (PPC_LO (r2off) != 0)
11011                 size += 4;
11012             }
11013         }
11014       else if (info->emitrelocations)
11015         {
11016           stub_entry->stub_sec->reloc_count += 1;
11017           stub_entry->stub_sec->flags |= SEC_RELOC;
11018         }
11019     }
11020
11021   stub_entry->stub_sec->size += size;
11022   return TRUE;
11023 }
11024
11025 /* Set up various things so that we can make a list of input sections
11026    for each output section included in the link.  Returns -1 on error,
11027    0 when no stubs will be needed, and 1 on success.  */
11028
11029 int
11030 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11031 {
11032   bfd *input_bfd;
11033   int top_id, top_index, id;
11034   asection *section;
11035   asection **input_list;
11036   bfd_size_type amt;
11037   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11038
11039   if (htab == NULL)
11040     return -1;
11041
11042   /* Find the top input section id.  */
11043   for (input_bfd = info->input_bfds, top_id = 3;
11044        input_bfd != NULL;
11045        input_bfd = input_bfd->link_next)
11046     {
11047       for (section = input_bfd->sections;
11048            section != NULL;
11049            section = section->next)
11050         {
11051           if (top_id < section->id)
11052             top_id = section->id;
11053         }
11054     }
11055
11056   htab->top_id = top_id;
11057   amt = sizeof (struct map_stub) * (top_id + 1);
11058   htab->stub_group = bfd_zmalloc (amt);
11059   if (htab->stub_group == NULL)
11060     return -1;
11061
11062   /* Set toc_off for com, und, abs and ind sections.  */
11063   for (id = 0; id < 3; id++)
11064     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11065
11066   /* We can't use output_bfd->section_count here to find the top output
11067      section index as some sections may have been removed, and
11068      strip_excluded_output_sections doesn't renumber the indices.  */
11069   for (section = info->output_bfd->sections, top_index = 0;
11070        section != NULL;
11071        section = section->next)
11072     {
11073       if (top_index < section->index)
11074         top_index = section->index;
11075     }
11076
11077   htab->top_index = top_index;
11078   amt = sizeof (asection *) * (top_index + 1);
11079   input_list = bfd_zmalloc (amt);
11080   htab->input_list = input_list;
11081   if (input_list == NULL)
11082     return -1;
11083
11084   return 1;
11085 }
11086
11087 /* Set up for first pass at multitoc partitioning.  */
11088
11089 void
11090 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11091 {
11092   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11093
11094   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11095   htab->toc_bfd = NULL;
11096   htab->toc_first_sec = NULL;
11097 }
11098
11099 /* The linker repeatedly calls this function for each TOC input section
11100    and linker generated GOT section.  Group input bfds such that the toc
11101    within a group is less than 64k in size.  */
11102
11103 bfd_boolean
11104 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11105 {
11106   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11107   bfd_vma addr, off, limit;
11108
11109   if (htab == NULL)
11110     return FALSE;
11111
11112   if (!htab->second_toc_pass)
11113     {
11114       /* Keep track of the first .toc or .got section for this input bfd.  */
11115       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11116
11117       if (new_bfd)
11118         {
11119           htab->toc_bfd = isec->owner;
11120           htab->toc_first_sec = isec;
11121         }
11122
11123       addr = isec->output_offset + isec->output_section->vma;
11124       off = addr - htab->toc_curr;
11125       limit = 0x80008000;
11126       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11127         limit = 0x10000;
11128       if (off + isec->size > limit)
11129         {
11130           addr = (htab->toc_first_sec->output_offset
11131                   + htab->toc_first_sec->output_section->vma);
11132           htab->toc_curr = addr;
11133         }
11134
11135       /* toc_curr is the base address of this toc group.  Set elf_gp
11136          for the input section to be the offset relative to the
11137          output toc base plus 0x8000.  Making the input elf_gp an
11138          offset allows us to move the toc as a whole without
11139          recalculating input elf_gp.  */
11140       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11141       off += TOC_BASE_OFF;
11142
11143       /* Die if someone uses a linker script that doesn't keep input
11144          file .toc and .got together.  */
11145       if (new_bfd
11146           && elf_gp (isec->owner) != 0
11147           && elf_gp (isec->owner) != off)
11148         return FALSE;
11149
11150       elf_gp (isec->owner) = off;
11151       return TRUE;
11152     }
11153
11154   /* During the second pass toc_first_sec points to the start of
11155      a toc group, and toc_curr is used to track the old elf_gp.
11156      We use toc_bfd to ensure we only look at each bfd once.  */
11157   if (htab->toc_bfd == isec->owner)
11158     return TRUE;
11159   htab->toc_bfd = isec->owner;
11160
11161   if (htab->toc_first_sec == NULL
11162       || htab->toc_curr != elf_gp (isec->owner))
11163     {
11164       htab->toc_curr = elf_gp (isec->owner);
11165       htab->toc_first_sec = isec;
11166     }
11167   addr = (htab->toc_first_sec->output_offset
11168           + htab->toc_first_sec->output_section->vma);
11169   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11170   elf_gp (isec->owner) = off;
11171
11172   return TRUE;
11173 }
11174
11175 /* Called via elf_link_hash_traverse to merge GOT entries for global
11176    symbol H.  */
11177
11178 static bfd_boolean
11179 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11180 {
11181   if (h->root.type == bfd_link_hash_indirect)
11182     return TRUE;
11183
11184   merge_got_entries (&h->got.glist);
11185
11186   return TRUE;
11187 }
11188
11189 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11190    symbol H.  */
11191
11192 static bfd_boolean
11193 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11194 {
11195   struct got_entry *gent;
11196
11197   if (h->root.type == bfd_link_hash_indirect)
11198     return TRUE;
11199
11200   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11201     if (!gent->is_indirect)
11202       allocate_got (h, (struct bfd_link_info *) inf, gent);
11203   return TRUE;
11204 }
11205
11206 /* Called on the first multitoc pass after the last call to
11207    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11208    entries.  */
11209
11210 bfd_boolean
11211 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11212 {
11213   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11214   struct bfd *ibfd, *ibfd2;
11215   bfd_boolean done_something;
11216
11217   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11218
11219   if (!htab->do_multi_toc)
11220     return FALSE;
11221
11222   /* Merge global sym got entries within a toc group.  */
11223   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11224
11225   /* And tlsld_got.  */
11226   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11227     {
11228       struct got_entry *ent, *ent2;
11229
11230       if (!is_ppc64_elf (ibfd))
11231         continue;
11232
11233       ent = ppc64_tlsld_got (ibfd);
11234       if (!ent->is_indirect
11235           && ent->got.offset != (bfd_vma) -1)
11236         {
11237           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11238             {
11239               if (!is_ppc64_elf (ibfd2))
11240                 continue;
11241
11242               ent2 = ppc64_tlsld_got (ibfd2);
11243               if (!ent2->is_indirect
11244                   && ent2->got.offset != (bfd_vma) -1
11245                   && elf_gp (ibfd2) == elf_gp (ibfd))
11246                 {
11247                   ent2->is_indirect = TRUE;
11248                   ent2->got.ent = ent;
11249                 }
11250             }
11251         }
11252     }
11253
11254   /* Zap sizes of got sections.  */
11255   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11256   htab->elf.irelplt->size -= htab->got_reli_size;
11257   htab->got_reli_size = 0;
11258
11259   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11260     {
11261       asection *got, *relgot;
11262
11263       if (!is_ppc64_elf (ibfd))
11264         continue;
11265
11266       got = ppc64_elf_tdata (ibfd)->got;
11267       if (got != NULL)
11268         {
11269           got->rawsize = got->size;
11270           got->size = 0;
11271           relgot = ppc64_elf_tdata (ibfd)->relgot;
11272           relgot->rawsize = relgot->size;
11273           relgot->size = 0;
11274         }
11275     }
11276
11277   /* Now reallocate the got, local syms first.  We don't need to
11278      allocate section contents again since we never increase size.  */
11279   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11280     {
11281       struct got_entry **lgot_ents;
11282       struct got_entry **end_lgot_ents;
11283       struct plt_entry **local_plt;
11284       struct plt_entry **end_local_plt;
11285       unsigned char *lgot_masks;
11286       bfd_size_type locsymcount;
11287       Elf_Internal_Shdr *symtab_hdr;
11288       asection *s;
11289
11290       if (!is_ppc64_elf (ibfd))
11291         continue;
11292
11293       lgot_ents = elf_local_got_ents (ibfd);
11294       if (!lgot_ents)
11295         continue;
11296
11297       symtab_hdr = &elf_symtab_hdr (ibfd);
11298       locsymcount = symtab_hdr->sh_info;
11299       end_lgot_ents = lgot_ents + locsymcount;
11300       local_plt = (struct plt_entry **) end_lgot_ents;
11301       end_local_plt = local_plt + locsymcount;
11302       lgot_masks = (unsigned char *) end_local_plt;
11303       s = ppc64_elf_tdata (ibfd)->got;
11304       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11305         {
11306           struct got_entry *ent;
11307
11308           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11309             {
11310               unsigned int ent_size = 8;
11311               unsigned int rel_size = sizeof (Elf64_External_Rela);
11312
11313               ent->got.offset = s->size;
11314               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11315                 {
11316                   ent_size *= 2;
11317                   rel_size *= 2;
11318                 }
11319               s->size += ent_size;
11320               if ((*lgot_masks & PLT_IFUNC) != 0)
11321                 {
11322                   htab->elf.irelplt->size += rel_size;
11323                   htab->got_reli_size += rel_size;
11324                 }
11325               else if (info->shared)
11326                 {
11327                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11328                   srel->size += rel_size;
11329                 }
11330             }
11331         }
11332     }
11333
11334   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11335
11336   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11337     {
11338       struct got_entry *ent;
11339
11340       if (!is_ppc64_elf (ibfd))
11341         continue;
11342
11343       ent = ppc64_tlsld_got (ibfd);
11344       if (!ent->is_indirect
11345           && ent->got.offset != (bfd_vma) -1)
11346         {
11347           asection *s = ppc64_elf_tdata (ibfd)->got;
11348           ent->got.offset = s->size;
11349           s->size += 16;
11350           if (info->shared)
11351             {
11352               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11353               srel->size += sizeof (Elf64_External_Rela);
11354             }
11355         }
11356     }
11357
11358   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11359   if (!done_something)
11360     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11361       {
11362         asection *got;
11363
11364         if (!is_ppc64_elf (ibfd))
11365           continue;
11366
11367         got = ppc64_elf_tdata (ibfd)->got;
11368         if (got != NULL)
11369           {
11370             done_something = got->rawsize != got->size;
11371             if (done_something)
11372               break;
11373           }
11374       }
11375
11376   if (done_something)
11377     (*htab->params->layout_sections_again) ();
11378
11379   /* Set up for second pass over toc sections to recalculate elf_gp
11380      on input sections.  */
11381   htab->toc_bfd = NULL;
11382   htab->toc_first_sec = NULL;
11383   htab->second_toc_pass = TRUE;
11384   return done_something;
11385 }
11386
11387 /* Called after second pass of multitoc partitioning.  */
11388
11389 void
11390 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11391 {
11392   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11393
11394   /* After the second pass, toc_curr tracks the TOC offset used
11395      for code sections below in ppc64_elf_next_input_section.  */
11396   htab->toc_curr = TOC_BASE_OFF;
11397 }
11398
11399 /* No toc references were found in ISEC.  If the code in ISEC makes no
11400    calls, then there's no need to use toc adjusting stubs when branching
11401    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11402    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11403    needed, and 2 if a cyclical call-graph was found but no other reason
11404    for a stub was detected.  If called from the top level, a return of
11405    2 means the same as a return of 0.  */
11406
11407 static int
11408 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11409 {
11410   int ret;
11411
11412   /* Mark this section as checked.  */
11413   isec->call_check_done = 1;
11414
11415   /* We know none of our code bearing sections will need toc stubs.  */
11416   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11417     return 0;
11418
11419   if (isec->size == 0)
11420     return 0;
11421
11422   if (isec->output_section == NULL)
11423     return 0;
11424
11425   ret = 0;
11426   if (isec->reloc_count != 0)
11427     {
11428       Elf_Internal_Rela *relstart, *rel;
11429       Elf_Internal_Sym *local_syms;
11430       struct ppc_link_hash_table *htab;
11431
11432       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11433                                             info->keep_memory);
11434       if (relstart == NULL)
11435         return -1;
11436
11437       /* Look for branches to outside of this section.  */
11438       local_syms = NULL;
11439       htab = ppc_hash_table (info);
11440       if (htab == NULL)
11441         return -1;
11442
11443       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11444         {
11445           enum elf_ppc64_reloc_type r_type;
11446           unsigned long r_symndx;
11447           struct elf_link_hash_entry *h;
11448           struct ppc_link_hash_entry *eh;
11449           Elf_Internal_Sym *sym;
11450           asection *sym_sec;
11451           struct _opd_sec_data *opd;
11452           bfd_vma sym_value;
11453           bfd_vma dest;
11454
11455           r_type = ELF64_R_TYPE (rel->r_info);
11456           if (r_type != R_PPC64_REL24
11457               && r_type != R_PPC64_REL14
11458               && r_type != R_PPC64_REL14_BRTAKEN
11459               && r_type != R_PPC64_REL14_BRNTAKEN)
11460             continue;
11461
11462           r_symndx = ELF64_R_SYM (rel->r_info);
11463           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11464                           isec->owner))
11465             {
11466               ret = -1;
11467               break;
11468             }
11469
11470           /* Calls to dynamic lib functions go through a plt call stub
11471              that uses r2.  */
11472           eh = (struct ppc_link_hash_entry *) h;
11473           if (eh != NULL
11474               && (eh->elf.plt.plist != NULL
11475                   || (eh->oh != NULL
11476                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11477             {
11478               ret = 1;
11479               break;
11480             }
11481
11482           if (sym_sec == NULL)
11483             /* Ignore other undefined symbols.  */
11484             continue;
11485
11486           /* Assume branches to other sections not included in the
11487              link need stubs too, to cover -R and absolute syms.  */
11488           if (sym_sec->output_section == NULL)
11489             {
11490               ret = 1;
11491               break;
11492             }
11493
11494           if (h == NULL)
11495             sym_value = sym->st_value;
11496           else
11497             {
11498               if (h->root.type != bfd_link_hash_defined
11499                   && h->root.type != bfd_link_hash_defweak)
11500                 abort ();
11501               sym_value = h->root.u.def.value;
11502             }
11503           sym_value += rel->r_addend;
11504
11505           /* If this branch reloc uses an opd sym, find the code section.  */
11506           opd = get_opd_info (sym_sec);
11507           if (opd != NULL)
11508             {
11509               if (h == NULL && opd->adjust != NULL)
11510                 {
11511                   long adjust;
11512
11513                   adjust = opd->adjust[sym->st_value / 8];
11514                   if (adjust == -1)
11515                     /* Assume deleted functions won't ever be called.  */
11516                     continue;
11517                   sym_value += adjust;
11518                 }
11519
11520               dest = opd_entry_value (sym_sec, sym_value,
11521                                       &sym_sec, NULL, FALSE);
11522               if (dest == (bfd_vma) -1)
11523                 continue;
11524             }
11525           else
11526             dest = (sym_value
11527                     + sym_sec->output_offset
11528                     + sym_sec->output_section->vma);
11529
11530           /* Ignore branch to self.  */
11531           if (sym_sec == isec)
11532             continue;
11533
11534           /* If the called function uses the toc, we need a stub.  */
11535           if (sym_sec->has_toc_reloc
11536               || sym_sec->makes_toc_func_call)
11537             {
11538               ret = 1;
11539               break;
11540             }
11541
11542           /* Assume any branch that needs a long branch stub might in fact
11543              need a plt_branch stub.  A plt_branch stub uses r2.  */
11544           else if (dest - (isec->output_offset
11545                            + isec->output_section->vma
11546                            + rel->r_offset) + (1 << 25)
11547                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11548                                                              ? h->other
11549                                                              : sym->st_other))
11550             {
11551               ret = 1;
11552               break;
11553             }
11554
11555           /* If calling back to a section in the process of being
11556              tested, we can't say for sure that no toc adjusting stubs
11557              are needed, so don't return zero.  */
11558           else if (sym_sec->call_check_in_progress)
11559             ret = 2;
11560
11561           /* Branches to another section that itself doesn't have any TOC
11562              references are OK.  Recursively call ourselves to check.  */
11563           else if (!sym_sec->call_check_done)
11564             {
11565               int recur;
11566
11567               /* Mark current section as indeterminate, so that other
11568                  sections that call back to current won't be marked as
11569                  known.  */
11570               isec->call_check_in_progress = 1;
11571               recur = toc_adjusting_stub_needed (info, sym_sec);
11572               isec->call_check_in_progress = 0;
11573
11574               if (recur != 0)
11575                 {
11576                   ret = recur;
11577                   if (recur != 2)
11578                     break;
11579                 }
11580             }
11581         }
11582
11583       if (local_syms != NULL
11584           && (elf_symtab_hdr (isec->owner).contents
11585               != (unsigned char *) local_syms))
11586         free (local_syms);
11587       if (elf_section_data (isec)->relocs != relstart)
11588         free (relstart);
11589     }
11590
11591   if ((ret & 1) == 0
11592       && isec->map_head.s != NULL
11593       && (strcmp (isec->output_section->name, ".init") == 0
11594           || strcmp (isec->output_section->name, ".fini") == 0))
11595     {
11596       if (isec->map_head.s->has_toc_reloc
11597           || isec->map_head.s->makes_toc_func_call)
11598         ret = 1;
11599       else if (!isec->map_head.s->call_check_done)
11600         {
11601           int recur;
11602           isec->call_check_in_progress = 1;
11603           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11604           isec->call_check_in_progress = 0;
11605           if (recur != 0)
11606             ret = recur;
11607         }
11608     }
11609
11610   if (ret == 1)
11611     isec->makes_toc_func_call = 1;
11612
11613   return ret;
11614 }
11615
11616 /* The linker repeatedly calls this function for each input section,
11617    in the order that input sections are linked into output sections.
11618    Build lists of input sections to determine groupings between which
11619    we may insert linker stubs.  */
11620
11621 bfd_boolean
11622 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11623 {
11624   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11625
11626   if (htab == NULL)
11627     return FALSE;
11628
11629   if ((isec->output_section->flags & SEC_CODE) != 0
11630       && isec->output_section->index <= htab->top_index)
11631     {
11632       asection **list = htab->input_list + isec->output_section->index;
11633       /* Steal the link_sec pointer for our list.  */
11634 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11635       /* This happens to make the list in reverse order,
11636          which is what we want.  */
11637       PREV_SEC (isec) = *list;
11638       *list = isec;
11639     }
11640
11641   if (htab->multi_toc_needed)
11642     {
11643       /* Analyse sections that aren't already flagged as needing a
11644          valid toc pointer.  Exclude .fixup for the linux kernel.
11645          .fixup contains branches, but only back to the function that
11646          hit an exception.  */
11647       if (!(isec->has_toc_reloc
11648             || (isec->flags & SEC_CODE) == 0
11649             || strcmp (isec->name, ".fixup") == 0
11650             || isec->call_check_done))
11651         {
11652           if (toc_adjusting_stub_needed (info, isec) < 0)
11653             return FALSE;
11654         }
11655       /* Make all sections use the TOC assigned for this object file.
11656          This will be wrong for pasted sections;  We fix that in
11657          check_pasted_section().  */
11658       if (elf_gp (isec->owner) != 0)
11659         htab->toc_curr = elf_gp (isec->owner);
11660     }
11661
11662   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11663   return TRUE;
11664 }
11665
11666 /* Check that all .init and .fini sections use the same toc, if they
11667    have toc relocs.  */
11668
11669 static bfd_boolean
11670 check_pasted_section (struct bfd_link_info *info, const char *name)
11671 {
11672   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11673
11674   if (o != NULL)
11675     {
11676       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11677       bfd_vma toc_off = 0;
11678       asection *i;
11679
11680       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11681         if (i->has_toc_reloc)
11682           {
11683             if (toc_off == 0)
11684               toc_off = htab->stub_group[i->id].toc_off;
11685             else if (toc_off != htab->stub_group[i->id].toc_off)
11686               return FALSE;
11687           }
11688
11689       if (toc_off == 0)
11690         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11691           if (i->makes_toc_func_call)
11692             {
11693               toc_off = htab->stub_group[i->id].toc_off;
11694               break;
11695             }
11696
11697       /* Make sure the whole pasted function uses the same toc offset.  */
11698       if (toc_off != 0)
11699         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11700           htab->stub_group[i->id].toc_off = toc_off;
11701     }
11702   return TRUE;
11703 }
11704
11705 bfd_boolean
11706 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11707 {
11708   return (check_pasted_section (info, ".init")
11709           & check_pasted_section (info, ".fini"));
11710 }
11711
11712 /* See whether we can group stub sections together.  Grouping stub
11713    sections may result in fewer stubs.  More importantly, we need to
11714    put all .init* and .fini* stubs at the beginning of the .init or
11715    .fini output sections respectively, because glibc splits the
11716    _init and _fini functions into multiple parts.  Putting a stub in
11717    the middle of a function is not a good idea.  */
11718
11719 static void
11720 group_sections (struct ppc_link_hash_table *htab,
11721                 bfd_size_type stub_group_size,
11722                 bfd_boolean stubs_always_before_branch)
11723 {
11724   asection **list;
11725   bfd_size_type stub14_group_size;
11726   bfd_boolean suppress_size_errors;
11727
11728   suppress_size_errors = FALSE;
11729   stub14_group_size = stub_group_size;
11730   if (stub_group_size == 1)
11731     {
11732       /* Default values.  */
11733       if (stubs_always_before_branch)
11734         {
11735           stub_group_size = 0x1e00000;
11736           stub14_group_size = 0x7800;
11737         }
11738       else
11739         {
11740           stub_group_size = 0x1c00000;
11741           stub14_group_size = 0x7000;
11742         }
11743       suppress_size_errors = TRUE;
11744     }
11745
11746   list = htab->input_list + htab->top_index;
11747   do
11748     {
11749       asection *tail = *list;
11750       while (tail != NULL)
11751         {
11752           asection *curr;
11753           asection *prev;
11754           bfd_size_type total;
11755           bfd_boolean big_sec;
11756           bfd_vma curr_toc;
11757
11758           curr = tail;
11759           total = tail->size;
11760           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11761                              && ppc64_elf_section_data (tail)->has_14bit_branch
11762                              ? stub14_group_size : stub_group_size);
11763           if (big_sec && !suppress_size_errors)
11764             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11765                                      tail->owner, tail);
11766           curr_toc = htab->stub_group[tail->id].toc_off;
11767
11768           while ((prev = PREV_SEC (curr)) != NULL
11769                  && ((total += curr->output_offset - prev->output_offset)
11770                      < (ppc64_elf_section_data (prev) != NULL
11771                         && ppc64_elf_section_data (prev)->has_14bit_branch
11772                         ? stub14_group_size : stub_group_size))
11773                  && htab->stub_group[prev->id].toc_off == curr_toc)
11774             curr = prev;
11775
11776           /* OK, the size from the start of CURR to the end is less
11777              than stub_group_size and thus can be handled by one stub
11778              section.  (or the tail section is itself larger than
11779              stub_group_size, in which case we may be toast.)  We
11780              should really be keeping track of the total size of stubs
11781              added here, as stubs contribute to the final output
11782              section size.  That's a little tricky, and this way will
11783              only break if stubs added make the total size more than
11784              2^25, ie. for the default stub_group_size, if stubs total
11785              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11786           do
11787             {
11788               prev = PREV_SEC (tail);
11789               /* Set up this stub group.  */
11790               htab->stub_group[tail->id].link_sec = curr;
11791             }
11792           while (tail != curr && (tail = prev) != NULL);
11793
11794           /* But wait, there's more!  Input sections up to stub_group_size
11795              bytes before the stub section can be handled by it too.
11796              Don't do this if we have a really large section after the
11797              stubs, as adding more stubs increases the chance that
11798              branches may not reach into the stub section.  */
11799           if (!stubs_always_before_branch && !big_sec)
11800             {
11801               total = 0;
11802               while (prev != NULL
11803                      && ((total += tail->output_offset - prev->output_offset)
11804                          < (ppc64_elf_section_data (prev) != NULL
11805                             && ppc64_elf_section_data (prev)->has_14bit_branch
11806                             ? stub14_group_size : stub_group_size))
11807                      && htab->stub_group[prev->id].toc_off == curr_toc)
11808                 {
11809                   tail = prev;
11810                   prev = PREV_SEC (tail);
11811                   htab->stub_group[tail->id].link_sec = curr;
11812                 }
11813             }
11814           tail = prev;
11815         }
11816     }
11817   while (list-- != htab->input_list);
11818   free (htab->input_list);
11819 #undef PREV_SEC
11820 }
11821
11822 static const unsigned char glink_eh_frame_cie[] =
11823 {
11824   0, 0, 0, 16,                          /* length.  */
11825   0, 0, 0, 0,                           /* id.  */
11826   1,                                    /* CIE version.  */
11827   'z', 'R', 0,                          /* Augmentation string.  */
11828   4,                                    /* Code alignment.  */
11829   0x78,                                 /* Data alignment.  */
11830   65,                                   /* RA reg.  */
11831   1,                                    /* Augmentation size.  */
11832   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11833   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11834 };
11835
11836 /* Stripping output sections is normally done before dynamic section
11837    symbols have been allocated.  This function is called later, and
11838    handles cases like htab->brlt which is mapped to its own output
11839    section.  */
11840
11841 static void
11842 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11843 {
11844   if (isec->size == 0
11845       && isec->output_section->size == 0
11846       && !(isec->output_section->flags & SEC_KEEP)
11847       && !bfd_section_removed_from_list (info->output_bfd,
11848                                          isec->output_section)
11849       && elf_section_data (isec->output_section)->dynindx == 0)
11850     {
11851       isec->output_section->flags |= SEC_EXCLUDE;
11852       bfd_section_list_remove (info->output_bfd, isec->output_section);
11853       info->output_bfd->section_count--;
11854     }
11855 }
11856
11857 /* Determine and set the size of the stub section for a final link.
11858
11859    The basic idea here is to examine all the relocations looking for
11860    PC-relative calls to a target that is unreachable with a "bl"
11861    instruction.  */
11862
11863 bfd_boolean
11864 ppc64_elf_size_stubs (struct bfd_link_info *info)
11865 {
11866   bfd_size_type stub_group_size;
11867   bfd_boolean stubs_always_before_branch;
11868   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11869
11870   if (htab == NULL)
11871     return FALSE;
11872
11873   if (htab->params->plt_thread_safe == -1 && !info->executable)
11874     htab->params->plt_thread_safe = 1;
11875   if (!htab->opd_abi)
11876     htab->params->plt_thread_safe = 0;
11877   else if (htab->params->plt_thread_safe == -1)
11878     {
11879       static const char *const thread_starter[] =
11880         {
11881           "pthread_create",
11882           /* libstdc++ */
11883           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11884           /* librt */
11885           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11886           "mq_notify", "create_timer",
11887           /* libanl */
11888           "getaddrinfo_a",
11889           /* libgomp */
11890           "GOMP_parallel_start",
11891           "GOMP_parallel_loop_static_start",
11892           "GOMP_parallel_loop_dynamic_start",
11893           "GOMP_parallel_loop_guided_start",
11894           "GOMP_parallel_loop_runtime_start",
11895           "GOMP_parallel_sections_start",
11896         };
11897       unsigned i;
11898
11899       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11900         {
11901           struct elf_link_hash_entry *h;
11902           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11903                                     FALSE, FALSE, TRUE);
11904           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11905           if (htab->params->plt_thread_safe)
11906             break;
11907         }
11908     }
11909   stubs_always_before_branch = htab->params->group_size < 0;
11910   if (htab->params->group_size < 0)
11911     stub_group_size = -htab->params->group_size;
11912   else
11913     stub_group_size = htab->params->group_size;
11914
11915   group_sections (htab, stub_group_size, stubs_always_before_branch);
11916
11917   while (1)
11918     {
11919       bfd *input_bfd;
11920       unsigned int bfd_indx;
11921       asection *stub_sec;
11922
11923       htab->stub_iteration += 1;
11924
11925       for (input_bfd = info->input_bfds, bfd_indx = 0;
11926            input_bfd != NULL;
11927            input_bfd = input_bfd->link_next, bfd_indx++)
11928         {
11929           Elf_Internal_Shdr *symtab_hdr;
11930           asection *section;
11931           Elf_Internal_Sym *local_syms = NULL;
11932
11933           if (!is_ppc64_elf (input_bfd))
11934             continue;
11935
11936           /* We'll need the symbol table in a second.  */
11937           symtab_hdr = &elf_symtab_hdr (input_bfd);
11938           if (symtab_hdr->sh_info == 0)
11939             continue;
11940
11941           /* Walk over each section attached to the input bfd.  */
11942           for (section = input_bfd->sections;
11943                section != NULL;
11944                section = section->next)
11945             {
11946               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11947
11948               /* If there aren't any relocs, then there's nothing more
11949                  to do.  */
11950               if ((section->flags & SEC_RELOC) == 0
11951                   || (section->flags & SEC_ALLOC) == 0
11952                   || (section->flags & SEC_LOAD) == 0
11953                   || (section->flags & SEC_CODE) == 0
11954                   || section->reloc_count == 0)
11955                 continue;
11956
11957               /* If this section is a link-once section that will be
11958                  discarded, then don't create any stubs.  */
11959               if (section->output_section == NULL
11960                   || section->output_section->owner != info->output_bfd)
11961                 continue;
11962
11963               /* Get the relocs.  */
11964               internal_relocs
11965                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11966                                              info->keep_memory);
11967               if (internal_relocs == NULL)
11968                 goto error_ret_free_local;
11969
11970               /* Now examine each relocation.  */
11971               irela = internal_relocs;
11972               irelaend = irela + section->reloc_count;
11973               for (; irela < irelaend; irela++)
11974                 {
11975                   enum elf_ppc64_reloc_type r_type;
11976                   unsigned int r_indx;
11977                   enum ppc_stub_type stub_type;
11978                   struct ppc_stub_hash_entry *stub_entry;
11979                   asection *sym_sec, *code_sec;
11980                   bfd_vma sym_value, code_value;
11981                   bfd_vma destination;
11982                   unsigned long local_off;
11983                   bfd_boolean ok_dest;
11984                   struct ppc_link_hash_entry *hash;
11985                   struct ppc_link_hash_entry *fdh;
11986                   struct elf_link_hash_entry *h;
11987                   Elf_Internal_Sym *sym;
11988                   char *stub_name;
11989                   const asection *id_sec;
11990                   struct _opd_sec_data *opd;
11991                   struct plt_entry *plt_ent;
11992
11993                   r_type = ELF64_R_TYPE (irela->r_info);
11994                   r_indx = ELF64_R_SYM (irela->r_info);
11995
11996                   if (r_type >= R_PPC64_max)
11997                     {
11998                       bfd_set_error (bfd_error_bad_value);
11999                       goto error_ret_free_internal;
12000                     }
12001
12002                   /* Only look for stubs on branch instructions.  */
12003                   if (r_type != R_PPC64_REL24
12004                       && r_type != R_PPC64_REL14
12005                       && r_type != R_PPC64_REL14_BRTAKEN
12006                       && r_type != R_PPC64_REL14_BRNTAKEN)
12007                     continue;
12008
12009                   /* Now determine the call target, its name, value,
12010                      section.  */
12011                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12012                                   r_indx, input_bfd))
12013                     goto error_ret_free_internal;
12014                   hash = (struct ppc_link_hash_entry *) h;
12015
12016                   ok_dest = FALSE;
12017                   fdh = NULL;
12018                   sym_value = 0;
12019                   if (hash == NULL)
12020                     {
12021                       sym_value = sym->st_value;
12022                       ok_dest = TRUE;
12023                     }
12024                   else if (hash->elf.root.type == bfd_link_hash_defined
12025                            || hash->elf.root.type == bfd_link_hash_defweak)
12026                     {
12027                       sym_value = hash->elf.root.u.def.value;
12028                       if (sym_sec->output_section != NULL)
12029                         ok_dest = TRUE;
12030                     }
12031                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12032                            || hash->elf.root.type == bfd_link_hash_undefined)
12033                     {
12034                       /* Recognise an old ABI func code entry sym, and
12035                          use the func descriptor sym instead if it is
12036                          defined.  */
12037                       if (hash->elf.root.root.string[0] == '.'
12038                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12039                         {
12040                           if (fdh->elf.root.type == bfd_link_hash_defined
12041                               || fdh->elf.root.type == bfd_link_hash_defweak)
12042                             {
12043                               sym_sec = fdh->elf.root.u.def.section;
12044                               sym_value = fdh->elf.root.u.def.value;
12045                               if (sym_sec->output_section != NULL)
12046                                 ok_dest = TRUE;
12047                             }
12048                           else
12049                             fdh = NULL;
12050                         }
12051                     }
12052                   else
12053                     {
12054                       bfd_set_error (bfd_error_bad_value);
12055                       goto error_ret_free_internal;
12056                     }
12057
12058                   destination = 0;
12059                   local_off = 0;
12060                   if (ok_dest)
12061                     {
12062                       sym_value += irela->r_addend;
12063                       destination = (sym_value
12064                                      + sym_sec->output_offset
12065                                      + sym_sec->output_section->vma);
12066                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12067                                                             ? hash->elf.other
12068                                                             : sym->st_other);
12069                     }
12070
12071                   code_sec = sym_sec;
12072                   code_value = sym_value;
12073                   opd = get_opd_info (sym_sec);
12074                   if (opd != NULL)
12075                     {
12076                       bfd_vma dest;
12077
12078                       if (hash == NULL && opd->adjust != NULL)
12079                         {
12080                           long adjust = opd->adjust[sym_value / 8];
12081                           if (adjust == -1)
12082                             continue;
12083                           code_value += adjust;
12084                           sym_value += adjust;
12085                         }
12086                       dest = opd_entry_value (sym_sec, sym_value,
12087                                               &code_sec, &code_value, FALSE);
12088                       if (dest != (bfd_vma) -1)
12089                         {
12090                           destination = dest;
12091                           if (fdh != NULL)
12092                             {
12093                               /* Fixup old ABI sym to point at code
12094                                  entry.  */
12095                               hash->elf.root.type = bfd_link_hash_defweak;
12096                               hash->elf.root.u.def.section = code_sec;
12097                               hash->elf.root.u.def.value = code_value;
12098                             }
12099                         }
12100                     }
12101
12102                   /* Determine what (if any) linker stub is needed.  */
12103                   plt_ent = NULL;
12104                   stub_type = ppc_type_of_stub (section, irela, &hash,
12105                                                 &plt_ent, destination,
12106                                                 local_off);
12107
12108                   if (stub_type != ppc_stub_plt_call)
12109                     {
12110                       /* Check whether we need a TOC adjusting stub.
12111                          Since the linker pastes together pieces from
12112                          different object files when creating the
12113                          _init and _fini functions, it may be that a
12114                          call to what looks like a local sym is in
12115                          fact a call needing a TOC adjustment.  */
12116                       if (code_sec != NULL
12117                           && code_sec->output_section != NULL
12118                           && (htab->stub_group[code_sec->id].toc_off
12119                               != htab->stub_group[section->id].toc_off)
12120                           && (code_sec->has_toc_reloc
12121                               || code_sec->makes_toc_func_call))
12122                         stub_type = ppc_stub_long_branch_r2off;
12123                     }
12124
12125                   if (stub_type == ppc_stub_none)
12126                     continue;
12127
12128                   /* __tls_get_addr calls might be eliminated.  */
12129                   if (stub_type != ppc_stub_plt_call
12130                       && hash != NULL
12131                       && (hash == htab->tls_get_addr
12132                           || hash == htab->tls_get_addr_fd)
12133                       && section->has_tls_reloc
12134                       && irela != internal_relocs)
12135                     {
12136                       /* Get tls info.  */
12137                       unsigned char *tls_mask;
12138
12139                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12140                                          irela - 1, input_bfd))
12141                         goto error_ret_free_internal;
12142                       if (*tls_mask != 0)
12143                         continue;
12144                     }
12145
12146                   if (stub_type == ppc_stub_plt_call
12147                       && irela + 1 < irelaend
12148                       && irela[1].r_offset == irela->r_offset + 4
12149                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12150                     {
12151                       if (!tocsave_find (htab, INSERT,
12152                                          &local_syms, irela + 1, input_bfd))
12153                         goto error_ret_free_internal;
12154                     }
12155                   else if (stub_type == ppc_stub_plt_call)
12156                     stub_type = ppc_stub_plt_call_r2save;
12157
12158                   /* Support for grouping stub sections.  */
12159                   id_sec = htab->stub_group[section->id].link_sec;
12160
12161                   /* Get the name of this stub.  */
12162                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12163                   if (!stub_name)
12164                     goto error_ret_free_internal;
12165
12166                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12167                                                      stub_name, FALSE, FALSE);
12168                   if (stub_entry != NULL)
12169                     {
12170                       /* The proper stub has already been created.  */
12171                       free (stub_name);
12172                       if (stub_type == ppc_stub_plt_call_r2save)
12173                         stub_entry->stub_type = stub_type;
12174                       continue;
12175                     }
12176
12177                   stub_entry = ppc_add_stub (stub_name, section, info);
12178                   if (stub_entry == NULL)
12179                     {
12180                       free (stub_name);
12181                     error_ret_free_internal:
12182                       if (elf_section_data (section)->relocs == NULL)
12183                         free (internal_relocs);
12184                     error_ret_free_local:
12185                       if (local_syms != NULL
12186                           && (symtab_hdr->contents
12187                               != (unsigned char *) local_syms))
12188                         free (local_syms);
12189                       return FALSE;
12190                     }
12191
12192                   stub_entry->stub_type = stub_type;
12193                   if (stub_type != ppc_stub_plt_call
12194                       && stub_type != ppc_stub_plt_call_r2save)
12195                     {
12196                       stub_entry->target_value = code_value;
12197                       stub_entry->target_section = code_sec;
12198                     }
12199                   else
12200                     {
12201                       stub_entry->target_value = sym_value;
12202                       stub_entry->target_section = sym_sec;
12203                     }
12204                   stub_entry->h = hash;
12205                   stub_entry->plt_ent = plt_ent;
12206                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12207
12208                   if (stub_entry->h != NULL)
12209                     htab->stub_globals += 1;
12210                 }
12211
12212               /* We're done with the internal relocs, free them.  */
12213               if (elf_section_data (section)->relocs != internal_relocs)
12214                 free (internal_relocs);
12215             }
12216
12217           if (local_syms != NULL
12218               && symtab_hdr->contents != (unsigned char *) local_syms)
12219             {
12220               if (!info->keep_memory)
12221                 free (local_syms);
12222               else
12223                 symtab_hdr->contents = (unsigned char *) local_syms;
12224             }
12225         }
12226
12227       /* We may have added some stubs.  Find out the new size of the
12228          stub sections.  */
12229       for (stub_sec = htab->params->stub_bfd->sections;
12230            stub_sec != NULL;
12231            stub_sec = stub_sec->next)
12232         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12233           {
12234             stub_sec->rawsize = stub_sec->size;
12235             stub_sec->size = 0;
12236             stub_sec->reloc_count = 0;
12237             stub_sec->flags &= ~SEC_RELOC;
12238           }
12239
12240       htab->brlt->size = 0;
12241       htab->brlt->reloc_count = 0;
12242       htab->brlt->flags &= ~SEC_RELOC;
12243       if (htab->relbrlt != NULL)
12244         htab->relbrlt->size = 0;
12245
12246       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12247
12248       if (info->emitrelocations
12249           && htab->glink != NULL && htab->glink->size != 0)
12250         {
12251           htab->glink->reloc_count = 1;
12252           htab->glink->flags |= SEC_RELOC;
12253         }
12254
12255       if (htab->glink_eh_frame != NULL
12256           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12257           && htab->glink_eh_frame->output_section->size != 0)
12258         {
12259           size_t size = 0, align;
12260
12261           for (stub_sec = htab->params->stub_bfd->sections;
12262                stub_sec != NULL;
12263                stub_sec = stub_sec->next)
12264             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12265               size += 20;
12266           if (htab->glink != NULL && htab->glink->size != 0)
12267             size += 24;
12268           if (size != 0)
12269             size += sizeof (glink_eh_frame_cie);
12270           align = 1;
12271           align <<= htab->glink_eh_frame->output_section->alignment_power;
12272           align -= 1;
12273           size = (size + align) & ~align;
12274           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12275           htab->glink_eh_frame->size = size;
12276         }
12277
12278       if (htab->params->plt_stub_align != 0)
12279         for (stub_sec = htab->params->stub_bfd->sections;
12280              stub_sec != NULL;
12281              stub_sec = stub_sec->next)
12282           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12283             stub_sec->size = ((stub_sec->size
12284                                + (1 << htab->params->plt_stub_align) - 1)
12285                               & (-1 << htab->params->plt_stub_align));
12286
12287       for (stub_sec = htab->params->stub_bfd->sections;
12288            stub_sec != NULL;
12289            stub_sec = stub_sec->next)
12290         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12291             && stub_sec->rawsize != stub_sec->size)
12292           break;
12293
12294       /* Exit from this loop when no stubs have been added, and no stubs
12295          have changed size.  */
12296       if (stub_sec == NULL
12297           && (htab->glink_eh_frame == NULL
12298               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12299         break;
12300
12301       /* Ask the linker to do its stuff.  */
12302       (*htab->params->layout_sections_again) ();
12303     }
12304
12305   maybe_strip_output (info, htab->brlt);
12306   if (htab->glink_eh_frame != NULL)
12307     maybe_strip_output (info, htab->glink_eh_frame);
12308
12309   return TRUE;
12310 }
12311
12312 /* Called after we have determined section placement.  If sections
12313    move, we'll be called again.  Provide a value for TOCstart.  */
12314
12315 bfd_vma
12316 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12317 {
12318   asection *s;
12319   bfd_vma TOCstart;
12320
12321   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12322      order.  The TOC starts where the first of these sections starts.  */
12323   s = bfd_get_section_by_name (obfd, ".got");
12324   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12325     s = bfd_get_section_by_name (obfd, ".toc");
12326   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12327     s = bfd_get_section_by_name (obfd, ".tocbss");
12328   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12329     s = bfd_get_section_by_name (obfd, ".plt");
12330   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12331     {
12332       /* This may happen for
12333          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12334          .toc directive
12335          o  bad linker script
12336          o --gc-sections and empty TOC sections
12337
12338          FIXME: Warn user?  */
12339
12340       /* Look for a likely section.  We probably won't even be
12341          using TOCstart.  */
12342       for (s = obfd->sections; s != NULL; s = s->next)
12343         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12344                          | SEC_EXCLUDE))
12345             == (SEC_ALLOC | SEC_SMALL_DATA))
12346           break;
12347       if (s == NULL)
12348         for (s = obfd->sections; s != NULL; s = s->next)
12349           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12350               == (SEC_ALLOC | SEC_SMALL_DATA))
12351             break;
12352       if (s == NULL)
12353         for (s = obfd->sections; s != NULL; s = s->next)
12354           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12355               == SEC_ALLOC)
12356             break;
12357       if (s == NULL)
12358         for (s = obfd->sections; s != NULL; s = s->next)
12359           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12360             break;
12361     }
12362
12363   TOCstart = 0;
12364   if (s != NULL)
12365     TOCstart = s->output_section->vma + s->output_offset;
12366
12367   _bfd_set_gp_value (obfd, TOCstart);
12368
12369   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12370     {
12371       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12372
12373       if (htab != NULL
12374           && htab->elf.hgot != NULL)
12375         {
12376           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12377           htab->elf.hgot->root.u.def.section = s;
12378         }
12379     }
12380   return TOCstart;
12381 }
12382
12383 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12384    write out any global entry stubs.  */
12385
12386 static bfd_boolean
12387 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12388 {
12389   struct bfd_link_info *info;
12390   struct ppc_link_hash_table *htab;
12391   struct plt_entry *pent;
12392   asection *s;
12393
12394   if (h->root.type == bfd_link_hash_indirect)
12395     return TRUE;
12396
12397   if (!h->pointer_equality_needed)
12398     return TRUE;
12399
12400   if (h->def_regular)
12401     return TRUE;
12402
12403   info = inf;
12404   htab = ppc_hash_table (info);
12405   if (htab == NULL)
12406     return FALSE;
12407
12408   s = htab->glink;
12409   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12410     if (pent->plt.offset != (bfd_vma) -1
12411         && pent->addend == 0)
12412       {
12413         bfd_byte *p;
12414         asection *plt;
12415         bfd_vma off;
12416
12417         p = s->contents + h->root.u.def.value;
12418         plt = htab->elf.splt;
12419         if (!htab->elf.dynamic_sections_created
12420             || h->dynindx == -1)
12421           plt = htab->elf.iplt;
12422         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12423         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12424
12425         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12426           {
12427             info->callbacks->einfo
12428               (_("%P: linkage table error against `%T'\n"),
12429                h->root.root.string);
12430             bfd_set_error (bfd_error_bad_value);
12431             htab->stub_error = TRUE;
12432           }
12433
12434         if (PPC_HA (off) != 0)
12435           {
12436             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12437             p += 4;
12438           }
12439         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12440         p += 4;
12441         bfd_put_32 (s->owner, MTCTR_R12, p);
12442         p += 4;
12443         bfd_put_32 (s->owner, BCTR, p);
12444         break;
12445       }
12446   return TRUE;
12447 }
12448
12449 /* Build all the stubs associated with the current output file.
12450    The stubs are kept in a hash table attached to the main linker
12451    hash table.  This function is called via gldelf64ppc_finish.  */
12452
12453 bfd_boolean
12454 ppc64_elf_build_stubs (struct bfd_link_info *info,
12455                        char **stats)
12456 {
12457   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12458   asection *stub_sec;
12459   bfd_byte *p;
12460   int stub_sec_count = 0;
12461
12462   if (htab == NULL)
12463     return FALSE;
12464
12465   /* Allocate memory to hold the linker stubs.  */
12466   for (stub_sec = htab->params->stub_bfd->sections;
12467        stub_sec != NULL;
12468        stub_sec = stub_sec->next)
12469     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12470         && stub_sec->size != 0)
12471       {
12472         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12473         if (stub_sec->contents == NULL)
12474           return FALSE;
12475         /* We want to check that built size is the same as calculated
12476            size.  rawsize is a convenient location to use.  */
12477         stub_sec->rawsize = stub_sec->size;
12478         stub_sec->size = 0;
12479       }
12480
12481   if (htab->glink != NULL && htab->glink->size != 0)
12482     {
12483       unsigned int indx;
12484       bfd_vma plt0;
12485
12486       /* Build the .glink plt call stub.  */
12487       if (htab->params->emit_stub_syms)
12488         {
12489           struct elf_link_hash_entry *h;
12490           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12491                                     TRUE, FALSE, FALSE);
12492           if (h == NULL)
12493             return FALSE;
12494           if (h->root.type == bfd_link_hash_new)
12495             {
12496               h->root.type = bfd_link_hash_defined;
12497               h->root.u.def.section = htab->glink;
12498               h->root.u.def.value = 8;
12499               h->ref_regular = 1;
12500               h->def_regular = 1;
12501               h->ref_regular_nonweak = 1;
12502               h->forced_local = 1;
12503               h->non_elf = 0;
12504             }
12505         }
12506       plt0 = (htab->elf.splt->output_section->vma
12507               + htab->elf.splt->output_offset
12508               - 16);
12509       if (info->emitrelocations)
12510         {
12511           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12512           if (r == NULL)
12513             return FALSE;
12514           r->r_offset = (htab->glink->output_offset
12515                          + htab->glink->output_section->vma);
12516           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12517           r->r_addend = plt0;
12518         }
12519       p = htab->glink->contents;
12520       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12521       bfd_put_64 (htab->glink->owner, plt0, p);
12522       p += 8;
12523       if (htab->opd_abi)
12524         {
12525           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12526           p += 4;
12527           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12528           p += 4;
12529           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12530           p += 4;
12531           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12532           p += 4;
12533           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12534           p += 4;
12535           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12536           p += 4;
12537           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12538           p += 4;
12539           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12540           p += 4;
12541           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12542           p += 4;
12543           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12544           p += 4;
12545         }
12546       else
12547         {
12548           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12549           p += 4;
12550           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12551           p += 4;
12552           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12553           p += 4;
12554           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12555           p += 4;
12556           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12557           p += 4;
12558           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12559           p += 4;
12560           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12561           p += 4;
12562           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12563           p += 4;
12564           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12565           p += 4;
12566           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12567           p += 4;
12568           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12569           p += 4;
12570           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12571           p += 4;
12572         }
12573       bfd_put_32 (htab->glink->owner, BCTR, p);
12574       p += 4;
12575       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12576         {
12577           bfd_put_32 (htab->glink->owner, NOP, p);
12578           p += 4;
12579         }
12580
12581       /* Build the .glink lazy link call stubs.  */
12582       indx = 0;
12583       while (p < htab->glink->contents + htab->glink->rawsize)
12584         {
12585           if (htab->opd_abi)
12586             {
12587               if (indx < 0x8000)
12588                 {
12589                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12590                   p += 4;
12591                 }
12592               else
12593                 {
12594                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12595                   p += 4;
12596                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12597                               p);
12598                   p += 4;
12599                 }
12600             }
12601           bfd_put_32 (htab->glink->owner,
12602                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12603           indx++;
12604           p += 4;
12605         }
12606
12607       /* Build .glink global entry stubs.  */
12608       if (htab->glink->size > htab->glink->rawsize)
12609         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12610     }
12611
12612   if (htab->brlt->size != 0)
12613     {
12614       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12615                                          htab->brlt->size);
12616       if (htab->brlt->contents == NULL)
12617         return FALSE;
12618     }
12619   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12620     {
12621       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12622                                             htab->relbrlt->size);
12623       if (htab->relbrlt->contents == NULL)
12624         return FALSE;
12625     }
12626
12627   if (htab->glink_eh_frame != NULL
12628       && htab->glink_eh_frame->size != 0)
12629     {
12630       bfd_vma val;
12631       bfd_byte *last_fde;
12632       size_t last_fde_len, size, align, pad;
12633
12634       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12635       if (p == NULL)
12636         return FALSE;
12637       htab->glink_eh_frame->contents = p;
12638       last_fde = p;
12639
12640       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12641
12642       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12643       /* CIE length (rewrite in case little-endian).  */
12644       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12645       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12646       p += sizeof (glink_eh_frame_cie);
12647
12648       for (stub_sec = htab->params->stub_bfd->sections;
12649            stub_sec != NULL;
12650            stub_sec = stub_sec->next)
12651         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12652           {
12653             last_fde = p;
12654             last_fde_len = 16;
12655             /* FDE length.  */
12656             bfd_put_32 (htab->elf.dynobj, 16, p);
12657             p += 4;
12658             /* CIE pointer.  */
12659             val = p - htab->glink_eh_frame->contents;
12660             bfd_put_32 (htab->elf.dynobj, val, p);
12661             p += 4;
12662             /* Offset to stub section.  */
12663             val = (stub_sec->output_section->vma
12664                    + stub_sec->output_offset);
12665             val -= (htab->glink_eh_frame->output_section->vma
12666                     + htab->glink_eh_frame->output_offset);
12667             val -= p - htab->glink_eh_frame->contents;
12668             if (val + 0x80000000 > 0xffffffff)
12669               {
12670                 info->callbacks->einfo
12671                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12672                    stub_sec->name);
12673                 return FALSE;
12674               }
12675             bfd_put_32 (htab->elf.dynobj, val, p);
12676             p += 4;
12677             /* stub section size.  */
12678             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12679             p += 4;
12680             /* Augmentation.  */
12681             p += 1;
12682             /* Pad.  */
12683             p += 3;
12684           }
12685       if (htab->glink != NULL && htab->glink->size != 0)
12686         {
12687           last_fde = p;
12688           last_fde_len = 20;
12689           /* FDE length.  */
12690           bfd_put_32 (htab->elf.dynobj, 20, p);
12691           p += 4;
12692           /* CIE pointer.  */
12693           val = p - htab->glink_eh_frame->contents;
12694           bfd_put_32 (htab->elf.dynobj, val, p);
12695           p += 4;
12696           /* Offset to .glink.  */
12697           val = (htab->glink->output_section->vma
12698                  + htab->glink->output_offset
12699                  + 8);
12700           val -= (htab->glink_eh_frame->output_section->vma
12701                   + htab->glink_eh_frame->output_offset);
12702           val -= p - htab->glink_eh_frame->contents;
12703           if (val + 0x80000000 > 0xffffffff)
12704             {
12705               info->callbacks->einfo
12706                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12707                  htab->glink->name);
12708               return FALSE;
12709             }
12710           bfd_put_32 (htab->elf.dynobj, val, p);
12711           p += 4;
12712           /* .glink size.  */
12713           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12714           p += 4;
12715           /* Augmentation.  */
12716           p += 1;
12717
12718           *p++ = DW_CFA_advance_loc + 1;
12719           *p++ = DW_CFA_register;
12720           *p++ = 65;
12721           *p++ = 12;
12722           *p++ = DW_CFA_advance_loc + 4;
12723           *p++ = DW_CFA_restore_extended;
12724           *p++ = 65;
12725         }
12726       /* Subsume any padding into the last FDE if user .eh_frame
12727          sections are aligned more than glink_eh_frame.  Otherwise any
12728          zero padding will be seen as a terminator.  */
12729       size = p - htab->glink_eh_frame->contents;
12730       align = 1;
12731       align <<= htab->glink_eh_frame->output_section->alignment_power;
12732       align -= 1;
12733       pad = ((size + align) & ~align) - size;
12734       htab->glink_eh_frame->size = size + pad;
12735       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12736     }
12737
12738   /* Build the stubs as directed by the stub hash table.  */
12739   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12740
12741   if (htab->relbrlt != NULL)
12742     htab->relbrlt->reloc_count = 0;
12743
12744   if (htab->params->plt_stub_align != 0)
12745     for (stub_sec = htab->params->stub_bfd->sections;
12746          stub_sec != NULL;
12747          stub_sec = stub_sec->next)
12748       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12749         stub_sec->size = ((stub_sec->size
12750                            + (1 << htab->params->plt_stub_align) - 1)
12751                           & (-1 << htab->params->plt_stub_align));
12752
12753   for (stub_sec = htab->params->stub_bfd->sections;
12754        stub_sec != NULL;
12755        stub_sec = stub_sec->next)
12756     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12757       {
12758         stub_sec_count += 1;
12759         if (stub_sec->rawsize != stub_sec->size)
12760           break;
12761       }
12762
12763   if (stub_sec != NULL
12764       || (htab->glink_eh_frame != NULL
12765           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12766     {
12767       htab->stub_error = TRUE;
12768       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12769     }
12770
12771   if (htab->stub_error)
12772     return FALSE;
12773
12774   if (stats != NULL)
12775     {
12776       *stats = bfd_malloc (500);
12777       if (*stats == NULL)
12778         return FALSE;
12779
12780       sprintf (*stats, _("linker stubs in %u group%s\n"
12781                          "  branch       %lu\n"
12782                          "  toc adjust   %lu\n"
12783                          "  long branch  %lu\n"
12784                          "  long toc adj %lu\n"
12785                          "  plt call     %lu\n"
12786                          "  plt call toc %lu"),
12787                stub_sec_count,
12788                stub_sec_count == 1 ? "" : "s",
12789                htab->stub_count[ppc_stub_long_branch - 1],
12790                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12791                htab->stub_count[ppc_stub_plt_branch - 1],
12792                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12793                htab->stub_count[ppc_stub_plt_call - 1],
12794                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12795     }
12796   return TRUE;
12797 }
12798
12799 /* This function undoes the changes made by add_symbol_adjust.  */
12800
12801 static bfd_boolean
12802 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12803 {
12804   struct ppc_link_hash_entry *eh;
12805
12806   if (h->root.type == bfd_link_hash_indirect)
12807     return TRUE;
12808
12809   eh = (struct ppc_link_hash_entry *) h;
12810   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12811     return TRUE;
12812
12813   eh->elf.root.type = bfd_link_hash_undefined;
12814   return TRUE;
12815 }
12816
12817 void
12818 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12819 {
12820   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12821
12822   if (htab != NULL)
12823     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12824 }
12825
12826 /* What to do when ld finds relocations against symbols defined in
12827    discarded sections.  */
12828
12829 static unsigned int
12830 ppc64_elf_action_discarded (asection *sec)
12831 {
12832   if (strcmp (".opd", sec->name) == 0)
12833     return 0;
12834
12835   if (strcmp (".toc", sec->name) == 0)
12836     return 0;
12837
12838   if (strcmp (".toc1", sec->name) == 0)
12839     return 0;
12840
12841   return _bfd_elf_default_action_discarded (sec);
12842 }
12843
12844 /* The RELOCATE_SECTION function is called by the ELF backend linker
12845    to handle the relocations for a section.
12846
12847    The relocs are always passed as Rela structures; if the section
12848    actually uses Rel structures, the r_addend field will always be
12849    zero.
12850
12851    This function is responsible for adjust the section contents as
12852    necessary, and (if using Rela relocs and generating a
12853    relocatable output file) adjusting the reloc addend as
12854    necessary.
12855
12856    This function does not have to worry about setting the reloc
12857    address or the reloc symbol index.
12858
12859    LOCAL_SYMS is a pointer to the swapped in local symbols.
12860
12861    LOCAL_SECTIONS is an array giving the section in the input file
12862    corresponding to the st_shndx field of each local symbol.
12863
12864    The global hash table entry for the global symbols can be found
12865    via elf_sym_hashes (input_bfd).
12866
12867    When generating relocatable output, this function must handle
12868    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12869    going to be the section symbol corresponding to the output
12870    section, which means that the addend must be adjusted
12871    accordingly.  */
12872
12873 static bfd_boolean
12874 ppc64_elf_relocate_section (bfd *output_bfd,
12875                             struct bfd_link_info *info,
12876                             bfd *input_bfd,
12877                             asection *input_section,
12878                             bfd_byte *contents,
12879                             Elf_Internal_Rela *relocs,
12880                             Elf_Internal_Sym *local_syms,
12881                             asection **local_sections)
12882 {
12883   struct ppc_link_hash_table *htab;
12884   Elf_Internal_Shdr *symtab_hdr;
12885   struct elf_link_hash_entry **sym_hashes;
12886   Elf_Internal_Rela *rel;
12887   Elf_Internal_Rela *relend;
12888   Elf_Internal_Rela outrel;
12889   bfd_byte *loc;
12890   struct got_entry **local_got_ents;
12891   bfd_vma TOCstart;
12892   bfd_boolean ret = TRUE;
12893   bfd_boolean is_opd;
12894   /* Assume 'at' branch hints.  */
12895   bfd_boolean is_isa_v2 = TRUE;
12896   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12897
12898   /* Initialize howto table if needed.  */
12899   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12900     ppc_howto_init ();
12901
12902   htab = ppc_hash_table (info);
12903   if (htab == NULL)
12904     return FALSE;
12905
12906   /* Don't relocate stub sections.  */
12907   if (input_section->owner == htab->params->stub_bfd)
12908     return TRUE;
12909
12910   BFD_ASSERT (is_ppc64_elf (input_bfd));
12911
12912   local_got_ents = elf_local_got_ents (input_bfd);
12913   TOCstart = elf_gp (output_bfd);
12914   symtab_hdr = &elf_symtab_hdr (input_bfd);
12915   sym_hashes = elf_sym_hashes (input_bfd);
12916   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12917
12918   rel = relocs;
12919   relend = relocs + input_section->reloc_count;
12920   for (; rel < relend; rel++)
12921     {
12922       enum elf_ppc64_reloc_type r_type;
12923       bfd_vma addend;
12924       bfd_reloc_status_type r;
12925       Elf_Internal_Sym *sym;
12926       asection *sec;
12927       struct elf_link_hash_entry *h_elf;
12928       struct ppc_link_hash_entry *h;
12929       struct ppc_link_hash_entry *fdh;
12930       const char *sym_name;
12931       unsigned long r_symndx, toc_symndx;
12932       bfd_vma toc_addend;
12933       unsigned char tls_mask, tls_gd, tls_type;
12934       unsigned char sym_type;
12935       bfd_vma relocation;
12936       bfd_boolean unresolved_reloc;
12937       bfd_boolean warned;
12938       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12939       unsigned int insn;
12940       unsigned int mask;
12941       struct ppc_stub_hash_entry *stub_entry;
12942       bfd_vma max_br_offset;
12943       bfd_vma from;
12944       const Elf_Internal_Rela orig_rel = *rel;
12945       reloc_howto_type *howto;
12946       struct reloc_howto_struct alt_howto;
12947
12948       r_type = ELF64_R_TYPE (rel->r_info);
12949       r_symndx = ELF64_R_SYM (rel->r_info);
12950
12951       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12952          symbol of the previous ADDR64 reloc.  The symbol gives us the
12953          proper TOC base to use.  */
12954       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12955           && rel != relocs
12956           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12957           && is_opd)
12958         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12959
12960       sym = NULL;
12961       sec = NULL;
12962       h_elf = NULL;
12963       sym_name = NULL;
12964       unresolved_reloc = FALSE;
12965       warned = FALSE;
12966
12967       if (r_symndx < symtab_hdr->sh_info)
12968         {
12969           /* It's a local symbol.  */
12970           struct _opd_sec_data *opd;
12971
12972           sym = local_syms + r_symndx;
12973           sec = local_sections[r_symndx];
12974           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12975           sym_type = ELF64_ST_TYPE (sym->st_info);
12976           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12977           opd = get_opd_info (sec);
12978           if (opd != NULL && opd->adjust != NULL)
12979             {
12980               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12981               if (adjust == -1)
12982                 relocation = 0;
12983               else
12984                 {
12985                   /* If this is a relocation against the opd section sym
12986                      and we have edited .opd, adjust the reloc addend so
12987                      that ld -r and ld --emit-relocs output is correct.
12988                      If it is a reloc against some other .opd symbol,
12989                      then the symbol value will be adjusted later.  */
12990                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12991                     rel->r_addend += adjust;
12992                   else
12993                     relocation += adjust;
12994                 }
12995             }
12996         }
12997       else
12998         {
12999           bfd_boolean ignored;
13000
13001           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13002                                    r_symndx, symtab_hdr, sym_hashes,
13003                                    h_elf, sec, relocation,
13004                                    unresolved_reloc, warned, ignored);
13005           sym_name = h_elf->root.root.string;
13006           sym_type = h_elf->type;
13007           if (sec != NULL
13008               && sec->owner == output_bfd
13009               && strcmp (sec->name, ".opd") == 0)
13010             {
13011               /* This is a symbol defined in a linker script.  All
13012                  such are defined in output sections, even those
13013                  defined by simple assignment from a symbol defined in
13014                  an input section.  Transfer the symbol to an
13015                  appropriate input .opd section, so that a branch to
13016                  this symbol will be mapped to the location specified
13017                  by the opd entry.  */
13018               struct bfd_link_order *lo;
13019               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13020                 if (lo->type == bfd_indirect_link_order)
13021                   {
13022                     asection *isec = lo->u.indirect.section;
13023                     if (h_elf->root.u.def.value >= isec->output_offset
13024                         && h_elf->root.u.def.value < (isec->output_offset
13025                                                       + isec->size))
13026                       {
13027                         h_elf->root.u.def.value -= isec->output_offset;
13028                         h_elf->root.u.def.section = isec;
13029                         sec = isec;
13030                         break;
13031                       }
13032                   }
13033             }
13034         }
13035       h = (struct ppc_link_hash_entry *) h_elf;
13036
13037       if (sec != NULL && discarded_section (sec))
13038         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13039                                          rel, 1, relend,
13040                                          ppc64_elf_howto_table[r_type], 0,
13041                                          contents);
13042
13043       if (info->relocatable)
13044         continue;
13045
13046       if (h != NULL && &h->elf == htab->elf.hgot)
13047         {
13048           relocation = (TOCstart
13049                         + htab->stub_group[input_section->id].toc_off);
13050           sec = bfd_abs_section_ptr;
13051           unresolved_reloc = FALSE;
13052         }
13053
13054       /* TLS optimizations.  Replace instruction sequences and relocs
13055          based on information we collected in tls_optimize.  We edit
13056          RELOCS so that --emit-relocs will output something sensible
13057          for the final instruction stream.  */
13058       tls_mask = 0;
13059       tls_gd = 0;
13060       toc_symndx = 0;
13061       if (h != NULL)
13062         tls_mask = h->tls_mask;
13063       else if (local_got_ents != NULL)
13064         {
13065           struct plt_entry **local_plt = (struct plt_entry **)
13066             (local_got_ents + symtab_hdr->sh_info);
13067           unsigned char *lgot_masks = (unsigned char *)
13068             (local_plt + symtab_hdr->sh_info);
13069           tls_mask = lgot_masks[r_symndx];
13070         }
13071       if (tls_mask == 0
13072           && (r_type == R_PPC64_TLS
13073               || r_type == R_PPC64_TLSGD
13074               || r_type == R_PPC64_TLSLD))
13075         {
13076           /* Check for toc tls entries.  */
13077           unsigned char *toc_tls;
13078
13079           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13080                              &local_syms, rel, input_bfd))
13081             return FALSE;
13082
13083           if (toc_tls)
13084             tls_mask = *toc_tls;
13085         }
13086
13087       /* Check that tls relocs are used with tls syms, and non-tls
13088          relocs are used with non-tls syms.  */
13089       if (r_symndx != STN_UNDEF
13090           && r_type != R_PPC64_NONE
13091           && (h == NULL
13092               || h->elf.root.type == bfd_link_hash_defined
13093               || h->elf.root.type == bfd_link_hash_defweak)
13094           && (IS_PPC64_TLS_RELOC (r_type)
13095               != (sym_type == STT_TLS
13096                   || (sym_type == STT_SECTION
13097                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13098         {
13099           if (tls_mask != 0
13100               && (r_type == R_PPC64_TLS
13101                   || r_type == R_PPC64_TLSGD
13102                   || r_type == R_PPC64_TLSLD))
13103             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13104             ;
13105           else
13106             info->callbacks->einfo
13107               (!IS_PPC64_TLS_RELOC (r_type)
13108                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13109                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13110                input_bfd, input_section, rel->r_offset,
13111                ppc64_elf_howto_table[r_type]->name,
13112                sym_name);
13113         }
13114
13115       /* Ensure reloc mapping code below stays sane.  */
13116       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13117           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13118           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13119           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13120           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13121           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13122           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13123           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13124           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13125           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13126         abort ();
13127
13128       switch (r_type)
13129         {
13130         default:
13131           break;
13132
13133         case R_PPC64_LO_DS_OPT:
13134           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13135           if ((insn & (0x3f << 26)) != 58u << 26)
13136             abort ();
13137           insn += (14u << 26) - (58u << 26);
13138           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13139           r_type = R_PPC64_TOC16_LO;
13140           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13141           break;
13142
13143         case R_PPC64_TOC16:
13144         case R_PPC64_TOC16_LO:
13145         case R_PPC64_TOC16_DS:
13146         case R_PPC64_TOC16_LO_DS:
13147           {
13148             /* Check for toc tls entries.  */
13149             unsigned char *toc_tls;
13150             int retval;
13151
13152             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13153                                    &local_syms, rel, input_bfd);
13154             if (retval == 0)
13155               return FALSE;
13156
13157             if (toc_tls)
13158               {
13159                 tls_mask = *toc_tls;
13160                 if (r_type == R_PPC64_TOC16_DS
13161                     || r_type == R_PPC64_TOC16_LO_DS)
13162                   {
13163                     if (tls_mask != 0
13164                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13165                       goto toctprel;
13166                   }
13167                 else
13168                   {
13169                     /* If we found a GD reloc pair, then we might be
13170                        doing a GD->IE transition.  */
13171                     if (retval == 2)
13172                       {
13173                         tls_gd = TLS_TPRELGD;
13174                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13175                           goto tls_ldgd_opt;
13176                       }
13177                     else if (retval == 3)
13178                       {
13179                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13180                           goto tls_ldgd_opt;
13181                       }
13182                   }
13183               }
13184           }
13185           break;
13186
13187         case R_PPC64_GOT_TPREL16_HI:
13188         case R_PPC64_GOT_TPREL16_HA:
13189           if (tls_mask != 0
13190               && (tls_mask & TLS_TPREL) == 0)
13191             {
13192               rel->r_offset -= d_offset;
13193               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13194               r_type = R_PPC64_NONE;
13195               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13196             }
13197           break;
13198
13199         case R_PPC64_GOT_TPREL16_DS:
13200         case R_PPC64_GOT_TPREL16_LO_DS:
13201           if (tls_mask != 0
13202               && (tls_mask & TLS_TPREL) == 0)
13203             {
13204             toctprel:
13205               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13206               insn &= 31 << 21;
13207               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13208               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13209               r_type = R_PPC64_TPREL16_HA;
13210               if (toc_symndx != 0)
13211                 {
13212                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13213                   rel->r_addend = toc_addend;
13214                   /* We changed the symbol.  Start over in order to
13215                      get h, sym, sec etc. right.  */
13216                   rel--;
13217                   continue;
13218                 }
13219               else
13220                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13221             }
13222           break;
13223
13224         case R_PPC64_TLS:
13225           if (tls_mask != 0
13226               && (tls_mask & TLS_TPREL) == 0)
13227             {
13228               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13229               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13230               if (insn == 0)
13231                 abort ();
13232               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13233               /* Was PPC64_TLS which sits on insn boundary, now
13234                  PPC64_TPREL16_LO which is at low-order half-word.  */
13235               rel->r_offset += d_offset;
13236               r_type = R_PPC64_TPREL16_LO;
13237               if (toc_symndx != 0)
13238                 {
13239                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13240                   rel->r_addend = toc_addend;
13241                   /* We changed the symbol.  Start over in order to
13242                      get h, sym, sec etc. right.  */
13243                   rel--;
13244                   continue;
13245                 }
13246               else
13247                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13248             }
13249           break;
13250
13251         case R_PPC64_GOT_TLSGD16_HI:
13252         case R_PPC64_GOT_TLSGD16_HA:
13253           tls_gd = TLS_TPRELGD;
13254           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13255             goto tls_gdld_hi;
13256           break;
13257
13258         case R_PPC64_GOT_TLSLD16_HI:
13259         case R_PPC64_GOT_TLSLD16_HA:
13260           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13261             {
13262             tls_gdld_hi:
13263               if ((tls_mask & tls_gd) != 0)
13264                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13265                           + R_PPC64_GOT_TPREL16_DS);
13266               else
13267                 {
13268                   rel->r_offset -= d_offset;
13269                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13270                   r_type = R_PPC64_NONE;
13271                 }
13272               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13273             }
13274           break;
13275
13276         case R_PPC64_GOT_TLSGD16:
13277         case R_PPC64_GOT_TLSGD16_LO:
13278           tls_gd = TLS_TPRELGD;
13279           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13280             goto tls_ldgd_opt;
13281           break;
13282
13283         case R_PPC64_GOT_TLSLD16:
13284         case R_PPC64_GOT_TLSLD16_LO:
13285           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13286             {
13287               unsigned int insn1, insn2, insn3;
13288               bfd_vma offset;
13289
13290             tls_ldgd_opt:
13291               offset = (bfd_vma) -1;
13292               /* If not using the newer R_PPC64_TLSGD/LD to mark
13293                  __tls_get_addr calls, we must trust that the call
13294                  stays with its arg setup insns, ie. that the next
13295                  reloc is the __tls_get_addr call associated with
13296                  the current reloc.  Edit both insns.  */
13297               if (input_section->has_tls_get_addr_call
13298                   && rel + 1 < relend
13299                   && branch_reloc_hash_match (input_bfd, rel + 1,
13300                                               htab->tls_get_addr,
13301                                               htab->tls_get_addr_fd))
13302                 offset = rel[1].r_offset;
13303               if ((tls_mask & tls_gd) != 0)
13304                 {
13305                   /* IE */
13306                   insn1 = bfd_get_32 (output_bfd,
13307                                       contents + rel->r_offset - d_offset);
13308                   insn1 &= (1 << 26) - (1 << 2);
13309                   insn1 |= 58 << 26;    /* ld */
13310                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13311                   if (offset != (bfd_vma) -1)
13312                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13313                   if ((tls_mask & TLS_EXPLICIT) == 0)
13314                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13315                               + R_PPC64_GOT_TPREL16_DS);
13316                   else
13317                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13318                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13319                 }
13320               else
13321                 {
13322                   /* LE */
13323                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13324                   insn2 = 0x38630000;   /* addi 3,3,0 */
13325                   if (tls_gd == 0)
13326                     {
13327                       /* Was an LD reloc.  */
13328                       if (toc_symndx)
13329                         sec = local_sections[toc_symndx];
13330                       for (r_symndx = 0;
13331                            r_symndx < symtab_hdr->sh_info;
13332                            r_symndx++)
13333                         if (local_sections[r_symndx] == sec)
13334                           break;
13335                       if (r_symndx >= symtab_hdr->sh_info)
13336                         r_symndx = STN_UNDEF;
13337                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13338                       if (r_symndx != STN_UNDEF)
13339                         rel->r_addend -= (local_syms[r_symndx].st_value
13340                                           + sec->output_offset
13341                                           + sec->output_section->vma);
13342                     }
13343                   else if (toc_symndx != 0)
13344                     {
13345                       r_symndx = toc_symndx;
13346                       rel->r_addend = toc_addend;
13347                     }
13348                   r_type = R_PPC64_TPREL16_HA;
13349                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13350                   if (offset != (bfd_vma) -1)
13351                     {
13352                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13353                                                     R_PPC64_TPREL16_LO);
13354                       rel[1].r_offset = offset + d_offset;
13355                       rel[1].r_addend = rel->r_addend;
13356                     }
13357                 }
13358               bfd_put_32 (output_bfd, insn1,
13359                           contents + rel->r_offset - d_offset);
13360               if (offset != (bfd_vma) -1)
13361                 {
13362                   insn3 = bfd_get_32 (output_bfd,
13363                                       contents + offset + 4);
13364                   if (insn3 == NOP
13365                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13366                     {
13367                       rel[1].r_offset += 4;
13368                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13369                       insn2 = NOP;
13370                     }
13371                   bfd_put_32 (output_bfd, insn2, contents + offset);
13372                 }
13373               if ((tls_mask & tls_gd) == 0
13374                   && (tls_gd == 0 || toc_symndx != 0))
13375                 {
13376                   /* We changed the symbol.  Start over in order
13377                      to get h, sym, sec etc. right.  */
13378                   rel--;
13379                   continue;
13380                 }
13381             }
13382           break;
13383
13384         case R_PPC64_TLSGD:
13385           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13386             {
13387               unsigned int insn2, insn3;
13388               bfd_vma offset = rel->r_offset;
13389
13390               if ((tls_mask & TLS_TPRELGD) != 0)
13391                 {
13392                   /* IE */
13393                   r_type = R_PPC64_NONE;
13394                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13395                 }
13396               else
13397                 {
13398                   /* LE */
13399                   if (toc_symndx != 0)
13400                     {
13401                       r_symndx = toc_symndx;
13402                       rel->r_addend = toc_addend;
13403                     }
13404                   r_type = R_PPC64_TPREL16_LO;
13405                   rel->r_offset = offset + d_offset;
13406                   insn2 = 0x38630000;   /* addi 3,3,0 */
13407                 }
13408               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13409               /* Zap the reloc on the _tls_get_addr call too.  */
13410               BFD_ASSERT (offset == rel[1].r_offset);
13411               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13412               insn3 = bfd_get_32 (output_bfd,
13413                                   contents + offset + 4);
13414               if (insn3 == NOP
13415                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13416                 {
13417                   rel->r_offset += 4;
13418                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13419                   insn2 = NOP;
13420                 }
13421               bfd_put_32 (output_bfd, insn2, contents + offset);
13422               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13423                 {
13424                   rel--;
13425                   continue;
13426                 }
13427             }
13428           break;
13429
13430         case R_PPC64_TLSLD:
13431           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13432             {
13433               unsigned int insn2, insn3;
13434               bfd_vma offset = rel->r_offset;
13435
13436               if (toc_symndx)
13437                 sec = local_sections[toc_symndx];
13438               for (r_symndx = 0;
13439                    r_symndx < symtab_hdr->sh_info;
13440                    r_symndx++)
13441                 if (local_sections[r_symndx] == sec)
13442                   break;
13443               if (r_symndx >= symtab_hdr->sh_info)
13444                 r_symndx = STN_UNDEF;
13445               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13446               if (r_symndx != STN_UNDEF)
13447                 rel->r_addend -= (local_syms[r_symndx].st_value
13448                                   + sec->output_offset
13449                                   + sec->output_section->vma);
13450
13451               r_type = R_PPC64_TPREL16_LO;
13452               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13453               rel->r_offset = offset + d_offset;
13454               /* Zap the reloc on the _tls_get_addr call too.  */
13455               BFD_ASSERT (offset == rel[1].r_offset);
13456               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13457               insn2 = 0x38630000;       /* addi 3,3,0 */
13458               insn3 = bfd_get_32 (output_bfd,
13459                                   contents + offset + 4);
13460               if (insn3 == NOP
13461                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13462                 {
13463                   rel->r_offset += 4;
13464                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13465                   insn2 = NOP;
13466                 }
13467               bfd_put_32 (output_bfd, insn2, contents + offset);
13468               rel--;
13469               continue;
13470             }
13471           break;
13472
13473         case R_PPC64_DTPMOD64:
13474           if (rel + 1 < relend
13475               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13476               && rel[1].r_offset == rel->r_offset + 8)
13477             {
13478               if ((tls_mask & TLS_GD) == 0)
13479                 {
13480                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13481                   if ((tls_mask & TLS_TPRELGD) != 0)
13482                     r_type = R_PPC64_TPREL64;
13483                   else
13484                     {
13485                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13486                       r_type = R_PPC64_NONE;
13487                     }
13488                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13489                 }
13490             }
13491           else
13492             {
13493               if ((tls_mask & TLS_LD) == 0)
13494                 {
13495                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13496                   r_type = R_PPC64_NONE;
13497                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13498                 }
13499             }
13500           break;
13501
13502         case R_PPC64_TPREL64:
13503           if ((tls_mask & TLS_TPREL) == 0)
13504             {
13505               r_type = R_PPC64_NONE;
13506               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13507             }
13508           break;
13509
13510         case R_PPC64_REL16_HA:
13511           /* If we are generating a non-PIC executable, edit
13512              .  0:      addis 2,12,.TOC.-0b@ha
13513              .          addi 2,2,.TOC.-0b@l
13514              used by ELFv2 global entry points to set up r2, to
13515              .          lis 2,.TOC.@ha
13516              .          addi 2,2,.TOC.@l
13517              if .TOC. is in range.  */
13518           if (!info->shared
13519               && h != NULL && &h->elf == htab->elf.hgot
13520               && rel + 1 < relend
13521               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13522               && rel[1].r_offset == rel->r_offset + 4
13523               && rel[1].r_addend == rel->r_addend + 4
13524               && relocation + 0x80008000 <= 0xffffffff)
13525             {
13526               unsigned int insn1, insn2;
13527               bfd_vma offset = rel->r_offset - d_offset;
13528               insn1 = bfd_get_32 (output_bfd, contents + offset);
13529               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13530               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13531                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13532                 {
13533                   r_type = R_PPC64_ADDR16_HA;
13534                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13535                   rel->r_addend -= d_offset;
13536                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13537                   rel[1].r_addend -= d_offset + 4;
13538                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13539                 }
13540             }
13541           break;
13542         }
13543
13544       /* Handle other relocations that tweak non-addend part of insn.  */
13545       insn = 0;
13546       max_br_offset = 1 << 25;
13547       addend = rel->r_addend;
13548       reloc_dest = DEST_NORMAL;
13549       switch (r_type)
13550         {
13551         default:
13552           break;
13553
13554         case R_PPC64_TOCSAVE:
13555           if (relocation + addend == (rel->r_offset
13556                                       + input_section->output_offset
13557                                       + input_section->output_section->vma)
13558               && tocsave_find (htab, NO_INSERT,
13559                                &local_syms, rel, input_bfd))
13560             {
13561               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13562               if (insn == NOP
13563                   || insn == CROR_151515 || insn == CROR_313131)
13564                 bfd_put_32 (input_bfd,
13565                             STD_R2_0R1 + STK_TOC (htab),
13566                             contents + rel->r_offset);
13567             }
13568           break;
13569
13570           /* Branch taken prediction relocations.  */
13571         case R_PPC64_ADDR14_BRTAKEN:
13572         case R_PPC64_REL14_BRTAKEN:
13573           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13574           /* Fall thru.  */
13575
13576           /* Branch not taken prediction relocations.  */
13577         case R_PPC64_ADDR14_BRNTAKEN:
13578         case R_PPC64_REL14_BRNTAKEN:
13579           insn |= bfd_get_32 (output_bfd,
13580                               contents + rel->r_offset) & ~(0x01 << 21);
13581           /* Fall thru.  */
13582
13583         case R_PPC64_REL14:
13584           max_br_offset = 1 << 15;
13585           /* Fall thru.  */
13586
13587         case R_PPC64_REL24:
13588           /* Calls to functions with a different TOC, such as calls to
13589              shared objects, need to alter the TOC pointer.  This is
13590              done using a linkage stub.  A REL24 branching to these
13591              linkage stubs needs to be followed by a nop, as the nop
13592              will be replaced with an instruction to restore the TOC
13593              base pointer.  */
13594           fdh = h;
13595           if (h != NULL
13596               && h->oh != NULL
13597               && h->oh->is_func_descriptor)
13598             fdh = ppc_follow_link (h->oh);
13599           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13600                                            htab);
13601           if (stub_entry != NULL
13602               && (stub_entry->stub_type == ppc_stub_plt_call
13603                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13604                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13605                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13606             {
13607               bfd_boolean can_plt_call = FALSE;
13608
13609               /* All of these stubs will modify r2, so there must be a
13610                  branch and link followed by a nop.  The nop is
13611                  replaced by an insn to restore r2.  */
13612               if (rel->r_offset + 8 <= input_section->size)
13613                 {
13614                   unsigned long br;
13615
13616                   br = bfd_get_32 (input_bfd,
13617                                    contents + rel->r_offset);
13618                   if ((br & 1) != 0)
13619                     {
13620                       unsigned long nop;
13621
13622                       nop = bfd_get_32 (input_bfd,
13623                                         contents + rel->r_offset + 4);
13624                       if (nop == NOP
13625                           || nop == CROR_151515 || nop == CROR_313131)
13626                         {
13627                           if (h != NULL
13628                               && (h == htab->tls_get_addr_fd
13629                                   || h == htab->tls_get_addr)
13630                               && !htab->params->no_tls_get_addr_opt)
13631                             {
13632                               /* Special stub used, leave nop alone.  */
13633                             }
13634                           else
13635                             bfd_put_32 (input_bfd,
13636                                         LD_R2_0R1 + STK_TOC (htab),
13637                                         contents + rel->r_offset + 4);
13638                           can_plt_call = TRUE;
13639                         }
13640                     }
13641                 }
13642
13643               if (!can_plt_call && h != NULL)
13644                 {
13645                   const char *name = h->elf.root.root.string;
13646
13647                   if (*name == '.')
13648                     ++name;
13649
13650                   if (strncmp (name, "__libc_start_main", 17) == 0
13651                       && (name[17] == 0 || name[17] == '@'))
13652                     {
13653                       /* Allow crt1 branch to go via a toc adjusting
13654                          stub.  Other calls that never return could do
13655                          the same, if we could detect such.  */
13656                       can_plt_call = TRUE;
13657                     }
13658                 }
13659
13660               if (!can_plt_call)
13661                 {
13662                   /* g++ as of 20130507 emits self-calls without a
13663                      following nop.  This is arguably wrong since we
13664                      have conflicting information.  On the one hand a
13665                      global symbol and on the other a local call
13666                      sequence, but don't error for this special case.
13667                      It isn't possible to cheaply verify we have
13668                      exactly such a call.  Allow all calls to the same
13669                      section.  */
13670                   asection *code_sec = sec;
13671
13672                   if (get_opd_info (sec) != NULL)
13673                     {
13674                       bfd_vma off = (relocation + addend
13675                                      - sec->output_section->vma
13676                                      - sec->output_offset);
13677
13678                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13679                     }
13680                   if (code_sec == input_section)
13681                     can_plt_call = TRUE;
13682                 }
13683
13684               if (!can_plt_call)
13685                 {
13686                   info->callbacks->einfo
13687                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13688                        "recompile with -fPIC\n"),
13689                      input_bfd, input_section, rel->r_offset, sym_name);
13690
13691                   bfd_set_error (bfd_error_bad_value);
13692                   ret = FALSE;
13693                 }
13694
13695               if (can_plt_call
13696                   && (stub_entry->stub_type == ppc_stub_plt_call
13697                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13698                 unresolved_reloc = FALSE;
13699             }
13700
13701           if ((stub_entry == NULL
13702                || stub_entry->stub_type == ppc_stub_long_branch
13703                || stub_entry->stub_type == ppc_stub_plt_branch)
13704               && get_opd_info (sec) != NULL)
13705             {
13706               /* The branch destination is the value of the opd entry. */
13707               bfd_vma off = (relocation + addend
13708                              - sec->output_section->vma
13709                              - sec->output_offset);
13710               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13711               if (dest != (bfd_vma) -1)
13712                 {
13713                   relocation = dest;
13714                   addend = 0;
13715                   reloc_dest = DEST_OPD;
13716                 }
13717             }
13718
13719           /* If the branch is out of reach we ought to have a long
13720              branch stub.  */
13721           from = (rel->r_offset
13722                   + input_section->output_offset
13723                   + input_section->output_section->vma);
13724
13725           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13726                                                   ? fdh->elf.other
13727                                                   : sym->st_other);
13728
13729           if (stub_entry != NULL
13730               && (stub_entry->stub_type == ppc_stub_long_branch
13731                   || stub_entry->stub_type == ppc_stub_plt_branch)
13732               && (r_type == R_PPC64_ADDR14_BRTAKEN
13733                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13734                   || (relocation + addend - from + max_br_offset
13735                       < 2 * max_br_offset)))
13736             /* Don't use the stub if this branch is in range.  */
13737             stub_entry = NULL;
13738
13739           if (stub_entry != NULL)
13740             {
13741               /* Munge up the value and addend so that we call the stub
13742                  rather than the procedure directly.  */
13743               relocation = (stub_entry->stub_offset
13744                             + stub_entry->stub_sec->output_offset
13745                             + stub_entry->stub_sec->output_section->vma);
13746               addend = 0;
13747               reloc_dest = DEST_STUB;
13748
13749               if ((stub_entry->stub_type == ppc_stub_plt_call
13750                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13751                   && (ALWAYS_EMIT_R2SAVE
13752                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13753                   && rel + 1 < relend
13754                   && rel[1].r_offset == rel->r_offset + 4
13755                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13756                 relocation += 4;
13757             }
13758
13759           if (insn != 0)
13760             {
13761               if (is_isa_v2)
13762                 {
13763                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13764                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13765                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13766                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13767                     insn |= 0x02 << 21;
13768                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13769                     insn |= 0x08 << 21;
13770                   else
13771                     break;
13772                 }
13773               else
13774                 {
13775                   /* Invert 'y' bit if not the default.  */
13776                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13777                     insn ^= 0x01 << 21;
13778                 }
13779
13780               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13781             }
13782
13783           /* NOP out calls to undefined weak functions.
13784              We can thus call a weak function without first
13785              checking whether the function is defined.  */
13786           else if (h != NULL
13787                    && h->elf.root.type == bfd_link_hash_undefweak
13788                    && h->elf.dynindx == -1
13789                    && r_type == R_PPC64_REL24
13790                    && relocation == 0
13791                    && addend == 0)
13792             {
13793               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13794               continue;
13795             }
13796           break;
13797         }
13798
13799       /* Set `addend'.  */
13800       tls_type = 0;
13801       switch (r_type)
13802         {
13803         default:
13804           info->callbacks->einfo
13805             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13806              input_bfd, (int) r_type, sym_name);
13807
13808           bfd_set_error (bfd_error_bad_value);
13809           ret = FALSE;
13810           continue;
13811
13812         case R_PPC64_NONE:
13813         case R_PPC64_TLS:
13814         case R_PPC64_TLSGD:
13815         case R_PPC64_TLSLD:
13816         case R_PPC64_TOCSAVE:
13817         case R_PPC64_GNU_VTINHERIT:
13818         case R_PPC64_GNU_VTENTRY:
13819           continue;
13820
13821           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13822              address in the GOT as relocation value instead of the
13823              symbol's value itself.  Also, create a GOT entry for the
13824              symbol and put the symbol value there.  */
13825         case R_PPC64_GOT_TLSGD16:
13826         case R_PPC64_GOT_TLSGD16_LO:
13827         case R_PPC64_GOT_TLSGD16_HI:
13828         case R_PPC64_GOT_TLSGD16_HA:
13829           tls_type = TLS_TLS | TLS_GD;
13830           goto dogot;
13831
13832         case R_PPC64_GOT_TLSLD16:
13833         case R_PPC64_GOT_TLSLD16_LO:
13834         case R_PPC64_GOT_TLSLD16_HI:
13835         case R_PPC64_GOT_TLSLD16_HA:
13836           tls_type = TLS_TLS | TLS_LD;
13837           goto dogot;
13838
13839         case R_PPC64_GOT_TPREL16_DS:
13840         case R_PPC64_GOT_TPREL16_LO_DS:
13841         case R_PPC64_GOT_TPREL16_HI:
13842         case R_PPC64_GOT_TPREL16_HA:
13843           tls_type = TLS_TLS | TLS_TPREL;
13844           goto dogot;
13845
13846         case R_PPC64_GOT_DTPREL16_DS:
13847         case R_PPC64_GOT_DTPREL16_LO_DS:
13848         case R_PPC64_GOT_DTPREL16_HI:
13849         case R_PPC64_GOT_DTPREL16_HA:
13850           tls_type = TLS_TLS | TLS_DTPREL;
13851           goto dogot;
13852
13853         case R_PPC64_GOT16:
13854         case R_PPC64_GOT16_LO:
13855         case R_PPC64_GOT16_HI:
13856         case R_PPC64_GOT16_HA:
13857         case R_PPC64_GOT16_DS:
13858         case R_PPC64_GOT16_LO_DS:
13859         dogot:
13860           {
13861             /* Relocation is to the entry for this symbol in the global
13862                offset table.  */
13863             asection *got;
13864             bfd_vma *offp;
13865             bfd_vma off;
13866             unsigned long indx = 0;
13867             struct got_entry *ent;
13868
13869             if (tls_type == (TLS_TLS | TLS_LD)
13870                 && (h == NULL
13871                     || !h->elf.def_dynamic))
13872               ent = ppc64_tlsld_got (input_bfd);
13873             else
13874               {
13875
13876                 if (h != NULL)
13877                   {
13878                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13879                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13880                                                           &h->elf)
13881                         || (info->shared
13882                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13883                       /* This is actually a static link, or it is a
13884                          -Bsymbolic link and the symbol is defined
13885                          locally, or the symbol was forced to be local
13886                          because of a version file.  */
13887                       ;
13888                     else
13889                       {
13890                         BFD_ASSERT (h->elf.dynindx != -1);
13891                         indx = h->elf.dynindx;
13892                         unresolved_reloc = FALSE;
13893                       }
13894                     ent = h->elf.got.glist;
13895                   }
13896                 else
13897                   {
13898                     if (local_got_ents == NULL)
13899                       abort ();
13900                     ent = local_got_ents[r_symndx];
13901                   }
13902
13903                 for (; ent != NULL; ent = ent->next)
13904                   if (ent->addend == orig_rel.r_addend
13905                       && ent->owner == input_bfd
13906                       && ent->tls_type == tls_type)
13907                     break;
13908               }
13909
13910             if (ent == NULL)
13911               abort ();
13912             if (ent->is_indirect)
13913               ent = ent->got.ent;
13914             offp = &ent->got.offset;
13915             got = ppc64_elf_tdata (ent->owner)->got;
13916             if (got == NULL)
13917               abort ();
13918
13919             /* The offset must always be a multiple of 8.  We use the
13920                least significant bit to record whether we have already
13921                processed this entry.  */
13922             off = *offp;
13923             if ((off & 1) != 0)
13924               off &= ~1;
13925             else
13926               {
13927                 /* Generate relocs for the dynamic linker, except in
13928                    the case of TLSLD where we'll use one entry per
13929                    module.  */
13930                 asection *relgot;
13931                 bfd_boolean ifunc;
13932
13933                 *offp = off | 1;
13934                 relgot = NULL;
13935                 ifunc = (h != NULL
13936                          ? h->elf.type == STT_GNU_IFUNC
13937                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13938                 if (ifunc)
13939                   relgot = htab->elf.irelplt;
13940                 else if ((info->shared || indx != 0)
13941                          && (h == NULL
13942                              || (tls_type == (TLS_TLS | TLS_LD)
13943                                  && !h->elf.def_dynamic)
13944                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13945                              || h->elf.root.type != bfd_link_hash_undefweak))
13946                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13947                 if (relgot != NULL)
13948                   {
13949                     outrel.r_offset = (got->output_section->vma
13950                                        + got->output_offset
13951                                        + off);
13952                     outrel.r_addend = addend;
13953                     if (tls_type & (TLS_LD | TLS_GD))
13954                       {
13955                         outrel.r_addend = 0;
13956                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13957                         if (tls_type == (TLS_TLS | TLS_GD))
13958                           {
13959                             loc = relgot->contents;
13960                             loc += (relgot->reloc_count++
13961                                     * sizeof (Elf64_External_Rela));
13962                             bfd_elf64_swap_reloca_out (output_bfd,
13963                                                        &outrel, loc);
13964                             outrel.r_offset += 8;
13965                             outrel.r_addend = addend;
13966                             outrel.r_info
13967                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13968                           }
13969                       }
13970                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13971                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13972                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13973                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13974                     else if (indx != 0)
13975                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13976                     else
13977                       {
13978                         if (ifunc)
13979                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13980                         else
13981                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13982
13983                         /* Write the .got section contents for the sake
13984                            of prelink.  */
13985                         loc = got->contents + off;
13986                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13987                                     loc);
13988                       }
13989
13990                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13991                       {
13992                         outrel.r_addend += relocation;
13993                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13994                           outrel.r_addend -= htab->elf.tls_sec->vma;
13995                       }
13996                     loc = relgot->contents;
13997                     loc += (relgot->reloc_count++
13998                             * sizeof (Elf64_External_Rela));
13999                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14000                   }
14001
14002                 /* Init the .got section contents here if we're not
14003                    emitting a reloc.  */
14004                 else
14005                   {
14006                     relocation += addend;
14007                     if (tls_type == (TLS_TLS | TLS_LD))
14008                       relocation = 1;
14009                     else if (tls_type != 0)
14010                       {
14011                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14012                         if (tls_type == (TLS_TLS | TLS_TPREL))
14013                           relocation += DTP_OFFSET - TP_OFFSET;
14014
14015                         if (tls_type == (TLS_TLS | TLS_GD))
14016                           {
14017                             bfd_put_64 (output_bfd, relocation,
14018                                         got->contents + off + 8);
14019                             relocation = 1;
14020                           }
14021                       }
14022
14023                     bfd_put_64 (output_bfd, relocation,
14024                                 got->contents + off);
14025                   }
14026               }
14027
14028             if (off >= (bfd_vma) -2)
14029               abort ();
14030
14031             relocation = got->output_section->vma + got->output_offset + off;
14032             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14033           }
14034           break;
14035
14036         case R_PPC64_PLT16_HA:
14037         case R_PPC64_PLT16_HI:
14038         case R_PPC64_PLT16_LO:
14039         case R_PPC64_PLT32:
14040         case R_PPC64_PLT64:
14041           /* Relocation is to the entry for this symbol in the
14042              procedure linkage table.  */
14043
14044           /* Resolve a PLT reloc against a local symbol directly,
14045              without using the procedure linkage table.  */
14046           if (h == NULL)
14047             break;
14048
14049           /* It's possible that we didn't make a PLT entry for this
14050              symbol.  This happens when statically linking PIC code,
14051              or when using -Bsymbolic.  Go find a match if there is a
14052              PLT entry.  */
14053           if (htab->elf.splt != NULL)
14054             {
14055               struct plt_entry *ent;
14056               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14057                 if (ent->plt.offset != (bfd_vma) -1
14058                     && ent->addend == orig_rel.r_addend)
14059                   {
14060                     relocation = (htab->elf.splt->output_section->vma
14061                                   + htab->elf.splt->output_offset
14062                                   + ent->plt.offset);
14063                     unresolved_reloc = FALSE;
14064                     break;
14065                   }
14066             }
14067           break;
14068
14069         case R_PPC64_TOC:
14070           /* Relocation value is TOC base.  */
14071           relocation = TOCstart;
14072           if (r_symndx == STN_UNDEF)
14073             relocation += htab->stub_group[input_section->id].toc_off;
14074           else if (unresolved_reloc)
14075             ;
14076           else if (sec != NULL && sec->id <= htab->top_id)
14077             relocation += htab->stub_group[sec->id].toc_off;
14078           else
14079             unresolved_reloc = TRUE;
14080           goto dodyn;
14081
14082           /* TOC16 relocs.  We want the offset relative to the TOC base,
14083              which is the address of the start of the TOC plus 0x8000.
14084              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14085              in this order.  */
14086         case R_PPC64_TOC16:
14087         case R_PPC64_TOC16_LO:
14088         case R_PPC64_TOC16_HI:
14089         case R_PPC64_TOC16_DS:
14090         case R_PPC64_TOC16_LO_DS:
14091         case R_PPC64_TOC16_HA:
14092           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14093           break;
14094
14095           /* Relocate against the beginning of the section.  */
14096         case R_PPC64_SECTOFF:
14097         case R_PPC64_SECTOFF_LO:
14098         case R_PPC64_SECTOFF_HI:
14099         case R_PPC64_SECTOFF_DS:
14100         case R_PPC64_SECTOFF_LO_DS:
14101         case R_PPC64_SECTOFF_HA:
14102           if (sec != NULL)
14103             addend -= sec->output_section->vma;
14104           break;
14105
14106         case R_PPC64_REL16:
14107         case R_PPC64_REL16_LO:
14108         case R_PPC64_REL16_HI:
14109         case R_PPC64_REL16_HA:
14110           break;
14111
14112         case R_PPC64_REL14:
14113         case R_PPC64_REL14_BRNTAKEN:
14114         case R_PPC64_REL14_BRTAKEN:
14115         case R_PPC64_REL24:
14116           break;
14117
14118         case R_PPC64_TPREL16:
14119         case R_PPC64_TPREL16_LO:
14120         case R_PPC64_TPREL16_HI:
14121         case R_PPC64_TPREL16_HA:
14122         case R_PPC64_TPREL16_DS:
14123         case R_PPC64_TPREL16_LO_DS:
14124         case R_PPC64_TPREL16_HIGH:
14125         case R_PPC64_TPREL16_HIGHA:
14126         case R_PPC64_TPREL16_HIGHER:
14127         case R_PPC64_TPREL16_HIGHERA:
14128         case R_PPC64_TPREL16_HIGHEST:
14129         case R_PPC64_TPREL16_HIGHESTA:
14130           if (h != NULL
14131               && h->elf.root.type == bfd_link_hash_undefweak
14132               && h->elf.dynindx == -1)
14133             {
14134               /* Make this relocation against an undefined weak symbol
14135                  resolve to zero.  This is really just a tweak, since
14136                  code using weak externs ought to check that they are
14137                  defined before using them.  */
14138               bfd_byte *p = contents + rel->r_offset - d_offset;
14139
14140               insn = bfd_get_32 (output_bfd, p);
14141               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14142               if (insn != 0)
14143                 bfd_put_32 (output_bfd, insn, p);
14144               break;
14145             }
14146           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14147           if (info->shared)
14148             /* The TPREL16 relocs shouldn't really be used in shared
14149                libs as they will result in DT_TEXTREL being set, but
14150                support them anyway.  */
14151             goto dodyn;
14152           break;
14153
14154         case R_PPC64_DTPREL16:
14155         case R_PPC64_DTPREL16_LO:
14156         case R_PPC64_DTPREL16_HI:
14157         case R_PPC64_DTPREL16_HA:
14158         case R_PPC64_DTPREL16_DS:
14159         case R_PPC64_DTPREL16_LO_DS:
14160         case R_PPC64_DTPREL16_HIGH:
14161         case R_PPC64_DTPREL16_HIGHA:
14162         case R_PPC64_DTPREL16_HIGHER:
14163         case R_PPC64_DTPREL16_HIGHERA:
14164         case R_PPC64_DTPREL16_HIGHEST:
14165         case R_PPC64_DTPREL16_HIGHESTA:
14166           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14167           break;
14168
14169         case R_PPC64_ADDR64_LOCAL:
14170           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14171                                               ? h->elf.other
14172                                               : sym->st_other);
14173           break;
14174
14175         case R_PPC64_DTPMOD64:
14176           relocation = 1;
14177           addend = 0;
14178           goto dodyn;
14179
14180         case R_PPC64_TPREL64:
14181           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14182           goto dodyn;
14183
14184         case R_PPC64_DTPREL64:
14185           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14186           /* Fall thru */
14187
14188           /* Relocations that may need to be propagated if this is a
14189              dynamic object.  */
14190         case R_PPC64_REL30:
14191         case R_PPC64_REL32:
14192         case R_PPC64_REL64:
14193         case R_PPC64_ADDR14:
14194         case R_PPC64_ADDR14_BRNTAKEN:
14195         case R_PPC64_ADDR14_BRTAKEN:
14196         case R_PPC64_ADDR16:
14197         case R_PPC64_ADDR16_DS:
14198         case R_PPC64_ADDR16_HA:
14199         case R_PPC64_ADDR16_HI:
14200         case R_PPC64_ADDR16_HIGH:
14201         case R_PPC64_ADDR16_HIGHA:
14202         case R_PPC64_ADDR16_HIGHER:
14203         case R_PPC64_ADDR16_HIGHERA:
14204         case R_PPC64_ADDR16_HIGHEST:
14205         case R_PPC64_ADDR16_HIGHESTA:
14206         case R_PPC64_ADDR16_LO:
14207         case R_PPC64_ADDR16_LO_DS:
14208         case R_PPC64_ADDR24:
14209         case R_PPC64_ADDR32:
14210         case R_PPC64_ADDR64:
14211         case R_PPC64_UADDR16:
14212         case R_PPC64_UADDR32:
14213         case R_PPC64_UADDR64:
14214         dodyn:
14215           if ((input_section->flags & SEC_ALLOC) == 0)
14216             break;
14217
14218           if (NO_OPD_RELOCS && is_opd)
14219             break;
14220
14221           if ((info->shared
14222                && (h == NULL
14223                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14224                    || h->elf.root.type != bfd_link_hash_undefweak)
14225                && (must_be_dyn_reloc (info, r_type)
14226                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14227               || (ELIMINATE_COPY_RELOCS
14228                   && !info->shared
14229                   && h != NULL
14230                   && h->elf.dynindx != -1
14231                   && !h->elf.non_got_ref
14232                   && !h->elf.def_regular)
14233               || (!info->shared
14234                   && (h != NULL
14235                       ? h->elf.type == STT_GNU_IFUNC
14236                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14237             {
14238               bfd_boolean skip, relocate;
14239               asection *sreloc;
14240               bfd_vma out_off;
14241
14242               /* When generating a dynamic object, these relocations
14243                  are copied into the output file to be resolved at run
14244                  time.  */
14245
14246               skip = FALSE;
14247               relocate = FALSE;
14248
14249               out_off = _bfd_elf_section_offset (output_bfd, info,
14250                                                  input_section, rel->r_offset);
14251               if (out_off == (bfd_vma) -1)
14252                 skip = TRUE;
14253               else if (out_off == (bfd_vma) -2)
14254                 skip = TRUE, relocate = TRUE;
14255               out_off += (input_section->output_section->vma
14256                           + input_section->output_offset);
14257               outrel.r_offset = out_off;
14258               outrel.r_addend = rel->r_addend;
14259
14260               /* Optimize unaligned reloc use.  */
14261               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14262                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14263                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14264               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14265                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14266                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14267               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14268                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14269                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14270
14271               if (skip)
14272                 memset (&outrel, 0, sizeof outrel);
14273               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14274                        && !is_opd
14275                        && r_type != R_PPC64_TOC)
14276                 {
14277                   BFD_ASSERT (h->elf.dynindx != -1);
14278                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14279                 }
14280               else
14281                 {
14282                   /* This symbol is local, or marked to become local,
14283                      or this is an opd section reloc which must point
14284                      at a local function.  */
14285                   outrel.r_addend += relocation;
14286                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14287                     {
14288                       if (is_opd && h != NULL)
14289                         {
14290                           /* Lie about opd entries.  This case occurs
14291                              when building shared libraries and we
14292                              reference a function in another shared
14293                              lib.  The same thing happens for a weak
14294                              definition in an application that's
14295                              overridden by a strong definition in a
14296                              shared lib.  (I believe this is a generic
14297                              bug in binutils handling of weak syms.)
14298                              In these cases we won't use the opd
14299                              entry in this lib.  */
14300                           unresolved_reloc = FALSE;
14301                         }
14302                       if (!is_opd
14303                           && r_type == R_PPC64_ADDR64
14304                           && (h != NULL
14305                               ? h->elf.type == STT_GNU_IFUNC
14306                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14307                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14308                       else
14309                         {
14310                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14311
14312                           /* We need to relocate .opd contents for ld.so.
14313                              Prelink also wants simple and consistent rules
14314                              for relocs.  This make all RELATIVE relocs have
14315                              *r_offset equal to r_addend.  */
14316                           relocate = TRUE;
14317                         }
14318                     }
14319                   else
14320                     {
14321                       long indx = 0;
14322
14323                       if (h != NULL
14324                           ? h->elf.type == STT_GNU_IFUNC
14325                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14326                         {
14327                           info->callbacks->einfo
14328                             (_("%P: %H: %s for indirect "
14329                                "function `%T' unsupported\n"),
14330                              input_bfd, input_section, rel->r_offset,
14331                              ppc64_elf_howto_table[r_type]->name,
14332                              sym_name);
14333                           ret = FALSE;
14334                         }
14335                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14336                         ;
14337                       else if (sec == NULL || sec->owner == NULL)
14338                         {
14339                           bfd_set_error (bfd_error_bad_value);
14340                           return FALSE;
14341                         }
14342                       else
14343                         {
14344                           asection *osec;
14345
14346                           osec = sec->output_section;
14347                           indx = elf_section_data (osec)->dynindx;
14348
14349                           if (indx == 0)
14350                             {
14351                               if ((osec->flags & SEC_READONLY) == 0
14352                                   && htab->elf.data_index_section != NULL)
14353                                 osec = htab->elf.data_index_section;
14354                               else
14355                                 osec = htab->elf.text_index_section;
14356                               indx = elf_section_data (osec)->dynindx;
14357                             }
14358                           BFD_ASSERT (indx != 0);
14359
14360                           /* We are turning this relocation into one
14361                              against a section symbol, so subtract out
14362                              the output section's address but not the
14363                              offset of the input section in the output
14364                              section.  */
14365                           outrel.r_addend -= osec->vma;
14366                         }
14367
14368                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14369                     }
14370                 }
14371
14372               sreloc = elf_section_data (input_section)->sreloc;
14373               if (h != NULL
14374                   ? h->elf.type == STT_GNU_IFUNC
14375                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14376                 sreloc = htab->elf.irelplt;
14377               if (sreloc == NULL)
14378                 abort ();
14379
14380               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14381                   >= sreloc->size)
14382                 abort ();
14383               loc = sreloc->contents;
14384               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14385               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14386
14387               /* If this reloc is against an external symbol, it will
14388                  be computed at runtime, so there's no need to do
14389                  anything now.  However, for the sake of prelink ensure
14390                  that the section contents are a known value.  */
14391               if (! relocate)
14392                 {
14393                   unresolved_reloc = FALSE;
14394                   /* The value chosen here is quite arbitrary as ld.so
14395                      ignores section contents except for the special
14396                      case of .opd where the contents might be accessed
14397                      before relocation.  Choose zero, as that won't
14398                      cause reloc overflow.  */
14399                   relocation = 0;
14400                   addend = 0;
14401                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14402                      to improve backward compatibility with older
14403                      versions of ld.  */
14404                   if (r_type == R_PPC64_ADDR64)
14405                     addend = outrel.r_addend;
14406                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14407                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14408                     addend = (input_section->output_section->vma
14409                               + input_section->output_offset
14410                               + rel->r_offset);
14411                 }
14412             }
14413           break;
14414
14415         case R_PPC64_COPY:
14416         case R_PPC64_GLOB_DAT:
14417         case R_PPC64_JMP_SLOT:
14418         case R_PPC64_JMP_IREL:
14419         case R_PPC64_RELATIVE:
14420           /* We shouldn't ever see these dynamic relocs in relocatable
14421              files.  */
14422           /* Fall through.  */
14423
14424         case R_PPC64_PLTGOT16:
14425         case R_PPC64_PLTGOT16_DS:
14426         case R_PPC64_PLTGOT16_HA:
14427         case R_PPC64_PLTGOT16_HI:
14428         case R_PPC64_PLTGOT16_LO:
14429         case R_PPC64_PLTGOT16_LO_DS:
14430         case R_PPC64_PLTREL32:
14431         case R_PPC64_PLTREL64:
14432           /* These ones haven't been implemented yet.  */
14433
14434           info->callbacks->einfo
14435             (_("%P: %B: %s is not supported for `%T'\n"),
14436              input_bfd,
14437              ppc64_elf_howto_table[r_type]->name, sym_name);
14438
14439           bfd_set_error (bfd_error_invalid_operation);
14440           ret = FALSE;
14441           continue;
14442         }
14443
14444       /* Multi-instruction sequences that access the TOC can be
14445          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14446          to             nop;           addi rb,r2,x;  */
14447       switch (r_type)
14448         {
14449         default:
14450           break;
14451
14452         case R_PPC64_GOT_TLSLD16_HI:
14453         case R_PPC64_GOT_TLSGD16_HI:
14454         case R_PPC64_GOT_TPREL16_HI:
14455         case R_PPC64_GOT_DTPREL16_HI:
14456         case R_PPC64_GOT16_HI:
14457         case R_PPC64_TOC16_HI:
14458           /* These relocs would only be useful if building up an
14459              offset to later add to r2, perhaps in an indexed
14460              addressing mode instruction.  Don't try to optimize.
14461              Unfortunately, the possibility of someone building up an
14462              offset like this or even with the HA relocs, means that
14463              we need to check the high insn when optimizing the low
14464              insn.  */
14465           break;
14466
14467         case R_PPC64_GOT_TLSLD16_HA:
14468         case R_PPC64_GOT_TLSGD16_HA:
14469         case R_PPC64_GOT_TPREL16_HA:
14470         case R_PPC64_GOT_DTPREL16_HA:
14471         case R_PPC64_GOT16_HA:
14472         case R_PPC64_TOC16_HA:
14473           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14474               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14475             {
14476               bfd_byte *p = contents + (rel->r_offset & ~3);
14477               bfd_put_32 (input_bfd, NOP, p);
14478             }
14479           break;
14480
14481         case R_PPC64_GOT_TLSLD16_LO:
14482         case R_PPC64_GOT_TLSGD16_LO:
14483         case R_PPC64_GOT_TPREL16_LO_DS:
14484         case R_PPC64_GOT_DTPREL16_LO_DS:
14485         case R_PPC64_GOT16_LO:
14486         case R_PPC64_GOT16_LO_DS:
14487         case R_PPC64_TOC16_LO:
14488         case R_PPC64_TOC16_LO_DS:
14489           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14490               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14491             {
14492               bfd_byte *p = contents + (rel->r_offset & ~3);
14493               insn = bfd_get_32 (input_bfd, p);
14494               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14495                 {
14496                   /* Transform addic to addi when we change reg.  */
14497                   insn &= ~((0x3f << 26) | (0x1f << 16));
14498                   insn |= (14u << 26) | (2 << 16);
14499                 }
14500               else
14501                 {
14502                   insn &= ~(0x1f << 16);
14503                   insn |= 2 << 16;
14504                 }
14505               bfd_put_32 (input_bfd, insn, p);
14506             }
14507           break;
14508         }
14509
14510       /* Do any further special processing.  */
14511       howto = ppc64_elf_howto_table[(int) r_type];
14512       switch (r_type)
14513         {
14514         default:
14515           break;
14516
14517         case R_PPC64_REL16_HA:
14518         case R_PPC64_ADDR16_HA:
14519         case R_PPC64_ADDR16_HIGHA:
14520         case R_PPC64_ADDR16_HIGHERA:
14521         case R_PPC64_ADDR16_HIGHESTA:
14522         case R_PPC64_TOC16_HA:
14523         case R_PPC64_SECTOFF_HA:
14524         case R_PPC64_TPREL16_HA:
14525         case R_PPC64_TPREL16_HIGHA:
14526         case R_PPC64_TPREL16_HIGHERA:
14527         case R_PPC64_TPREL16_HIGHESTA:
14528         case R_PPC64_DTPREL16_HA:
14529         case R_PPC64_DTPREL16_HIGHA:
14530         case R_PPC64_DTPREL16_HIGHERA:
14531         case R_PPC64_DTPREL16_HIGHESTA:
14532           /* It's just possible that this symbol is a weak symbol
14533              that's not actually defined anywhere. In that case,
14534              'sec' would be NULL, and we should leave the symbol
14535              alone (it will be set to zero elsewhere in the link).  */
14536           if (sec == NULL)
14537             break;
14538           /* Fall thru */
14539
14540         case R_PPC64_GOT16_HA:
14541         case R_PPC64_PLTGOT16_HA:
14542         case R_PPC64_PLT16_HA:
14543         case R_PPC64_GOT_TLSGD16_HA:
14544         case R_PPC64_GOT_TLSLD16_HA:
14545         case R_PPC64_GOT_TPREL16_HA:
14546         case R_PPC64_GOT_DTPREL16_HA:
14547           /* Add 0x10000 if sign bit in 0:15 is set.
14548              Bits 0:15 are not used.  */
14549           addend += 0x8000;
14550           break;
14551
14552         case R_PPC64_ADDR16_DS:
14553         case R_PPC64_ADDR16_LO_DS:
14554         case R_PPC64_GOT16_DS:
14555         case R_PPC64_GOT16_LO_DS:
14556         case R_PPC64_PLT16_LO_DS:
14557         case R_PPC64_SECTOFF_DS:
14558         case R_PPC64_SECTOFF_LO_DS:
14559         case R_PPC64_TOC16_DS:
14560         case R_PPC64_TOC16_LO_DS:
14561         case R_PPC64_PLTGOT16_DS:
14562         case R_PPC64_PLTGOT16_LO_DS:
14563         case R_PPC64_GOT_TPREL16_DS:
14564         case R_PPC64_GOT_TPREL16_LO_DS:
14565         case R_PPC64_GOT_DTPREL16_DS:
14566         case R_PPC64_GOT_DTPREL16_LO_DS:
14567         case R_PPC64_TPREL16_DS:
14568         case R_PPC64_TPREL16_LO_DS:
14569         case R_PPC64_DTPREL16_DS:
14570         case R_PPC64_DTPREL16_LO_DS:
14571           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14572           mask = 3;
14573           /* If this reloc is against an lq insn, then the value must be
14574              a multiple of 16.  This is somewhat of a hack, but the
14575              "correct" way to do this by defining _DQ forms of all the
14576              _DS relocs bloats all reloc switches in this file.  It
14577              doesn't seem to make much sense to use any of these relocs
14578              in data, so testing the insn should be safe.  */
14579           if ((insn & (0x3f << 26)) == (56u << 26))
14580             mask = 15;
14581           if (((relocation + addend) & mask) != 0)
14582             {
14583               info->callbacks->einfo
14584                 (_("%P: %H: error: %s not a multiple of %u\n"),
14585                  input_bfd, input_section, rel->r_offset,
14586                  howto->name,
14587                  mask + 1);
14588               bfd_set_error (bfd_error_bad_value);
14589               ret = FALSE;
14590               continue;
14591             }
14592           break;
14593         }
14594
14595       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14596          because such sections are not SEC_ALLOC and thus ld.so will
14597          not process them.  */
14598       if (unresolved_reloc
14599           && !((input_section->flags & SEC_DEBUGGING) != 0
14600                && h->elf.def_dynamic)
14601           && _bfd_elf_section_offset (output_bfd, info, input_section,
14602                                       rel->r_offset) != (bfd_vma) -1)
14603         {
14604           info->callbacks->einfo
14605             (_("%P: %H: unresolvable %s against `%T'\n"),
14606              input_bfd, input_section, rel->r_offset,
14607              howto->name,
14608              h->elf.root.root.string);
14609           ret = FALSE;
14610         }
14611
14612       /* 16-bit fields in insns mostly have signed values, but a
14613          few insns have 16-bit unsigned values.  Really, we should
14614          have different reloc types.  */
14615       if (howto->complain_on_overflow != complain_overflow_dont
14616           && howto->dst_mask == 0xffff
14617           && (input_section->flags & SEC_CODE) != 0)
14618         {
14619           enum complain_overflow complain = complain_overflow_signed;
14620
14621           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14622           if (howto->rightshift == 0
14623               ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14624                  || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14625                  || (insn & (0x3f << 26)) == 26u << 26 /* xori */
14626                  || (insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14627               : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14628                  || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14629                  || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14630             complain = complain_overflow_unsigned;
14631           if (howto->complain_on_overflow != complain)
14632             {
14633               alt_howto = *howto;
14634               alt_howto.complain_on_overflow = complain;
14635               howto = &alt_howto;
14636             }
14637         }
14638
14639       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14640                                     rel->r_offset, relocation, addend);
14641
14642       if (r != bfd_reloc_ok)
14643         {
14644           char *more_info = NULL;
14645           const char *reloc_name = howto->name;
14646
14647           if (reloc_dest != DEST_NORMAL)
14648             {
14649               more_info = bfd_malloc (strlen (reloc_name) + 8);
14650               if (more_info != NULL)
14651                 {
14652                   strcpy (more_info, reloc_name);
14653                   strcat (more_info, (reloc_dest == DEST_OPD
14654                                       ? " (OPD)" : " (stub)"));
14655                   reloc_name = more_info;
14656                 }
14657             }
14658
14659           if (r == bfd_reloc_overflow)
14660             {
14661               if (warned)
14662                 continue;
14663               if (h != NULL
14664                   && h->elf.root.type == bfd_link_hash_undefweak
14665                   && howto->pc_relative)
14666                 {
14667                   /* Assume this is a call protected by other code that
14668                      detects the symbol is undefined.  If this is the case,
14669                      we can safely ignore the overflow.  If not, the
14670                      program is hosed anyway, and a little warning isn't
14671                      going to help.  */
14672
14673                   continue;
14674                 }
14675
14676               if (!((*info->callbacks->reloc_overflow)
14677                     (info, &h->elf.root, sym_name,
14678                      reloc_name, orig_rel.r_addend,
14679                      input_bfd, input_section, rel->r_offset)))
14680                 return FALSE;
14681             }
14682           else
14683             {
14684               info->callbacks->einfo
14685                 (_("%P: %H: %s against `%T': error %d\n"),
14686                  input_bfd, input_section, rel->r_offset,
14687                  reloc_name, sym_name, (int) r);
14688               ret = FALSE;
14689             }
14690           if (more_info != NULL)
14691             free (more_info);
14692         }
14693     }
14694
14695   /* If we're emitting relocations, then shortly after this function
14696      returns, reloc offsets and addends for this section will be
14697      adjusted.  Worse, reloc symbol indices will be for the output
14698      file rather than the input.  Save a copy of the relocs for
14699      opd_entry_value.  */
14700   if (is_opd && (info->emitrelocations || info->relocatable))
14701     {
14702       bfd_size_type amt;
14703       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14704       rel = bfd_alloc (input_bfd, amt);
14705       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14706       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14707       if (rel == NULL)
14708         return FALSE;
14709       memcpy (rel, relocs, amt);
14710     }
14711   return ret;
14712 }
14713
14714 /* Adjust the value of any local symbols in opd sections.  */
14715
14716 static int
14717 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14718                               const char *name ATTRIBUTE_UNUSED,
14719                               Elf_Internal_Sym *elfsym,
14720                               asection *input_sec,
14721                               struct elf_link_hash_entry *h)
14722 {
14723   struct _opd_sec_data *opd;
14724   long adjust;
14725   bfd_vma value;
14726
14727   if (h != NULL)
14728     return 1;
14729
14730   opd = get_opd_info (input_sec);
14731   if (opd == NULL || opd->adjust == NULL)
14732     return 1;
14733
14734   value = elfsym->st_value - input_sec->output_offset;
14735   if (!info->relocatable)
14736     value -= input_sec->output_section->vma;
14737
14738   adjust = opd->adjust[value / 8];
14739   if (adjust == -1)
14740     return 2;
14741
14742   elfsym->st_value += adjust;
14743   return 1;
14744 }
14745
14746 /* Finish up dynamic symbol handling.  We set the contents of various
14747    dynamic sections here.  */
14748
14749 static bfd_boolean
14750 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14751                                  struct bfd_link_info *info,
14752                                  struct elf_link_hash_entry *h,
14753                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14754 {
14755   struct ppc_link_hash_table *htab;
14756   struct plt_entry *ent;
14757   Elf_Internal_Rela rela;
14758   bfd_byte *loc;
14759
14760   htab = ppc_hash_table (info);
14761   if (htab == NULL)
14762     return FALSE;
14763
14764   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14765     if (ent->plt.offset != (bfd_vma) -1)
14766       {
14767         /* This symbol has an entry in the procedure linkage
14768            table.  Set it up.  */
14769         if (!htab->elf.dynamic_sections_created
14770             || h->dynindx == -1)
14771           {
14772             BFD_ASSERT (h->type == STT_GNU_IFUNC
14773                         && h->def_regular
14774                         && (h->root.type == bfd_link_hash_defined
14775                             || h->root.type == bfd_link_hash_defweak));
14776             rela.r_offset = (htab->elf.iplt->output_section->vma
14777                              + htab->elf.iplt->output_offset
14778                              + ent->plt.offset);
14779             if (htab->opd_abi)
14780               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14781             else
14782               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14783             rela.r_addend = (h->root.u.def.value
14784                              + h->root.u.def.section->output_offset
14785                              + h->root.u.def.section->output_section->vma
14786                              + ent->addend);
14787             loc = (htab->elf.irelplt->contents
14788                    + (htab->elf.irelplt->reloc_count++
14789                       * sizeof (Elf64_External_Rela)));
14790           }
14791         else
14792           {
14793             rela.r_offset = (htab->elf.splt->output_section->vma
14794                              + htab->elf.splt->output_offset
14795                              + ent->plt.offset);
14796             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14797             rela.r_addend = ent->addend;
14798             loc = (htab->elf.srelplt->contents
14799                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14800                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14801           }
14802         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14803
14804         if (!htab->opd_abi)
14805           {
14806             if (!h->def_regular)
14807               {
14808                 /* Mark the symbol as undefined, rather than as
14809                    defined in glink.  Leave the value if there were
14810                    any relocations where pointer equality matters
14811                    (this is a clue for the dynamic linker, to make
14812                    function pointer comparisons work between an
14813                    application and shared library), otherwise set it
14814                    to zero.  */
14815                 sym->st_shndx = SHN_UNDEF;
14816                 if (!h->pointer_equality_needed)
14817                   sym->st_value = 0;
14818                 else if (!h->ref_regular_nonweak)
14819                   {
14820                     /* This breaks function pointer comparisons, but
14821                        that is better than breaking tests for a NULL
14822                        function pointer.  */
14823                     sym->st_value = 0;
14824                   }
14825               }
14826           }
14827       }
14828
14829   if (h->needs_copy)
14830     {
14831       /* This symbol needs a copy reloc.  Set it up.  */
14832
14833       if (h->dynindx == -1
14834           || (h->root.type != bfd_link_hash_defined
14835               && h->root.type != bfd_link_hash_defweak)
14836           || htab->relbss == NULL)
14837         abort ();
14838
14839       rela.r_offset = (h->root.u.def.value
14840                        + h->root.u.def.section->output_section->vma
14841                        + h->root.u.def.section->output_offset);
14842       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14843       rela.r_addend = 0;
14844       loc = htab->relbss->contents;
14845       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14846       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14847     }
14848
14849   return TRUE;
14850 }
14851
14852 /* Used to decide how to sort relocs in an optimal manner for the
14853    dynamic linker, before writing them out.  */
14854
14855 static enum elf_reloc_type_class
14856 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14857                             const asection *rel_sec,
14858                             const Elf_Internal_Rela *rela)
14859 {
14860   enum elf_ppc64_reloc_type r_type;
14861   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14862
14863   if (rel_sec == htab->elf.irelplt)
14864     return reloc_class_ifunc;
14865
14866   r_type = ELF64_R_TYPE (rela->r_info);
14867   switch (r_type)
14868     {
14869     case R_PPC64_RELATIVE:
14870       return reloc_class_relative;
14871     case R_PPC64_JMP_SLOT:
14872       return reloc_class_plt;
14873     case R_PPC64_COPY:
14874       return reloc_class_copy;
14875     default:
14876       return reloc_class_normal;
14877     }
14878 }
14879
14880 /* Finish up the dynamic sections.  */
14881
14882 static bfd_boolean
14883 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14884                                    struct bfd_link_info *info)
14885 {
14886   struct ppc_link_hash_table *htab;
14887   bfd *dynobj;
14888   asection *sdyn;
14889
14890   htab = ppc_hash_table (info);
14891   if (htab == NULL)
14892     return FALSE;
14893
14894   dynobj = htab->elf.dynobj;
14895   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14896
14897   if (htab->elf.dynamic_sections_created)
14898     {
14899       Elf64_External_Dyn *dyncon, *dynconend;
14900
14901       if (sdyn == NULL || htab->elf.sgot == NULL)
14902         abort ();
14903
14904       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14905       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14906       for (; dyncon < dynconend; dyncon++)
14907         {
14908           Elf_Internal_Dyn dyn;
14909           asection *s;
14910
14911           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14912
14913           switch (dyn.d_tag)
14914             {
14915             default:
14916               continue;
14917
14918             case DT_PPC64_GLINK:
14919               s = htab->glink;
14920               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14921               /* We stupidly defined DT_PPC64_GLINK to be the start
14922                  of glink rather than the first entry point, which is
14923                  what ld.so needs, and now have a bigger stub to
14924                  support automatic multiple TOCs.  */
14925               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14926               break;
14927
14928             case DT_PPC64_OPD:
14929               s = bfd_get_section_by_name (output_bfd, ".opd");
14930               if (s == NULL)
14931                 continue;
14932               dyn.d_un.d_ptr = s->vma;
14933               break;
14934
14935             case DT_PPC64_OPT:
14936               if (htab->do_multi_toc && htab->multi_toc_needed)
14937                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14938               break;
14939
14940             case DT_PPC64_OPDSZ:
14941               s = bfd_get_section_by_name (output_bfd, ".opd");
14942               if (s == NULL)
14943                 continue;
14944               dyn.d_un.d_val = s->size;
14945               break;
14946
14947             case DT_PLTGOT:
14948               s = htab->elf.splt;
14949               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14950               break;
14951
14952             case DT_JMPREL:
14953               s = htab->elf.srelplt;
14954               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14955               break;
14956
14957             case DT_PLTRELSZ:
14958               dyn.d_un.d_val = htab->elf.srelplt->size;
14959               break;
14960
14961             case DT_RELASZ:
14962               /* Don't count procedure linkage table relocs in the
14963                  overall reloc count.  */
14964               s = htab->elf.srelplt;
14965               if (s == NULL)
14966                 continue;
14967               dyn.d_un.d_val -= s->size;
14968               break;
14969
14970             case DT_RELA:
14971               /* We may not be using the standard ELF linker script.
14972                  If .rela.plt is the first .rela section, we adjust
14973                  DT_RELA to not include it.  */
14974               s = htab->elf.srelplt;
14975               if (s == NULL)
14976                 continue;
14977               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14978                 continue;
14979               dyn.d_un.d_ptr += s->size;
14980               break;
14981             }
14982
14983           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14984         }
14985     }
14986
14987   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14988     {
14989       /* Fill in the first entry in the global offset table.
14990          We use it to hold the link-time TOCbase.  */
14991       bfd_put_64 (output_bfd,
14992                   elf_gp (output_bfd) + TOC_BASE_OFF,
14993                   htab->elf.sgot->contents);
14994
14995       /* Set .got entry size.  */
14996       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14997     }
14998
14999   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15000     {
15001       /* Set .plt entry size.  */
15002       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15003         = PLT_ENTRY_SIZE (htab);
15004     }
15005
15006   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15007      brlt ourselves if emitrelocations.  */
15008   if (htab->brlt != NULL
15009       && htab->brlt->reloc_count != 0
15010       && !_bfd_elf_link_output_relocs (output_bfd,
15011                                        htab->brlt,
15012                                        elf_section_data (htab->brlt)->rela.hdr,
15013                                        elf_section_data (htab->brlt)->relocs,
15014                                        NULL))
15015     return FALSE;
15016
15017   if (htab->glink != NULL
15018       && htab->glink->reloc_count != 0
15019       && !_bfd_elf_link_output_relocs (output_bfd,
15020                                        htab->glink,
15021                                        elf_section_data (htab->glink)->rela.hdr,
15022                                        elf_section_data (htab->glink)->relocs,
15023                                        NULL))
15024     return FALSE;
15025
15026
15027   if (htab->glink_eh_frame != NULL
15028       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15029       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15030                                            htab->glink_eh_frame,
15031                                            htab->glink_eh_frame->contents))
15032     return FALSE;
15033
15034   /* We need to handle writing out multiple GOT sections ourselves,
15035      since we didn't add them to DYNOBJ.  We know dynobj is the first
15036      bfd.  */
15037   while ((dynobj = dynobj->link_next) != NULL)
15038     {
15039       asection *s;
15040
15041       if (!is_ppc64_elf (dynobj))
15042         continue;
15043
15044       s = ppc64_elf_tdata (dynobj)->got;
15045       if (s != NULL
15046           && s->size != 0
15047           && s->output_section != bfd_abs_section_ptr
15048           && !bfd_set_section_contents (output_bfd, s->output_section,
15049                                         s->contents, s->output_offset,
15050                                         s->size))
15051         return FALSE;
15052       s = ppc64_elf_tdata (dynobj)->relgot;
15053       if (s != NULL
15054           && s->size != 0
15055           && s->output_section != bfd_abs_section_ptr
15056           && !bfd_set_section_contents (output_bfd, s->output_section,
15057                                         s->contents, s->output_offset,
15058                                         s->size))
15059         return FALSE;
15060     }
15061
15062   return TRUE;
15063 }
15064
15065 #include "elf64-target.h"
15066
15067 /* FreeBSD support */
15068
15069 #undef  TARGET_LITTLE_SYM
15070 #undef  TARGET_LITTLE_NAME
15071
15072 #undef  TARGET_BIG_SYM
15073 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15074 #undef  TARGET_BIG_NAME
15075 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15076
15077 #undef  ELF_OSABI
15078 #define ELF_OSABI       ELFOSABI_FREEBSD
15079
15080 #undef  elf64_bed
15081 #define elf64_bed       elf64_powerpc_fbsd_bed
15082
15083 #include "elf64-target.h"
15084