bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  99 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 109 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 110 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 111 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 112 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 113 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 114 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 115 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 116 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 117 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 118 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 119 #define elf_backend_special_sections          ppc64_elf_special_sections
 120 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 121
 122 /* The name of the dynamic interpreter.  This is put in the .interp
 123    section.  */
 124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 125
 126 /* The size in bytes of an entry in the procedure linkage table.  */
 127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 128
 129 /* The initial size of the plt reserved for the dynamic linker.  */
 130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 131
 132 /* Offsets to some stack save slots.  */
 133 #define STK_LR 16
 134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 135 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 136    CR save slot.  Used only by optimised __tls_get_addr call stub,
 137    relying on __tls_get_addr_opt not saving CR..  */
 138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 139
 140 /* TOC base pointers offset from start of TOC.  */
 141 #define TOC_BASE_OFF    0x8000
 142
 143 /* Offset of tp and dtp pointers from start of TLS block.  */
 144 #define TP_OFFSET       0x7000
 145 #define DTP_OFFSET      0x8000
 146
 147 /* .plt call stub instructions.  The normal stub is like this, but
 148    sometimes the .plt entry crosses a 64k boundary and we need to
 149    insert an addi to adjust r11.  */
 150 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 151 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 152 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 153 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 154 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 155 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 156 #define BCTR            0x4e800420      /* bctr                      */
 157
 158 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 159 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 160 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 161
 162 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 163 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 164 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 165 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 166 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 167 #define BNECTR          0x4ca20420      /* bnectr+               */
 168 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 169
 170 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 171 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 172 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 173
 174 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 175
 176 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 177 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 178
 179 /* glink call stub instructions.  We enter with the index in R0.  */
 180 #define GLINK_CALL_STUB_SIZE (16*4)
 181                                         /* 0:                           */
 182                                         /*  .quad plt0-1f               */
 183                                         /* __glink:                     */
 184 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 185 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 186                                         /* 1:                           */
 187 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 188                                         /*  ld %2,(0b-1b)(%11)          */
 189 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 190 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 191                                         /*  ld %12,0(%11)               */
 192                                         /*  ld %2,8(%11)                */
 193                                         /*  mtctr %12                   */
 194                                         /*  ld %11,16(%11)              */
 195                                         /*  bctr                        */
 196 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 197 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 198 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 199 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 200 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 201
 202 /* Pad with this.  */
 203 #define NOP             0x60000000
 204
 205 /* Some other nops.  */
 206 #define CROR_151515     0x4def7b82
 207 #define CROR_313131     0x4ffffb82
 208
 209 /* .glink entries for the first 32k functions are two instructions.  */
 210 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 211 #define B_DOT           0x48000000      /* b     .              */
 212
 213 /* After that, we need two instructions to load the index, followed by
 214    a branch.  */
 215 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 216 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 217
 218 /* Instructions used by the save and restore reg functions.  */
 219 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 220 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 221 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 222 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 223 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 224 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 225 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 226 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 227 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 228 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 229 #define BLR             0x4e800020      /* blr                  */
 230
 231 /* Since .opd is an array of descriptors and each entry will end up
 232    with identical R_PPC64_RELATIVE relocs, there is really no need to
 233    propagate .opd relocs;  The dynamic linker should be taught to
 234    relocate .opd without reloc entries.  */
 235 #ifndef NO_OPD_RELOCS
 236 #define NO_OPD_RELOCS 0
 237 #endif
 238 \f
 239 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 240
 241 /* Relocation HOWTO's.  */
 242 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 243
 244 static reloc_howto_type ppc64_elf_howto_raw[] = {
 245   /* This reloc does nothing.  */
 246   HOWTO (R_PPC64_NONE,          /* type */
 247          0,                     /* rightshift */
 248          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 249          32,                    /* bitsize */
 250          FALSE,                 /* pc_relative */
 251          0,                     /* bitpos */
 252          complain_overflow_dont, /* complain_on_overflow */
 253          bfd_elf_generic_reloc, /* special_function */
 254          "R_PPC64_NONE",        /* name */
 255          FALSE,                 /* partial_inplace */
 256          0,                     /* src_mask */
 257          0,                     /* dst_mask */
 258          FALSE),                /* pcrel_offset */
 259
 260   /* A standard 32 bit relocation.  */
 261   HOWTO (R_PPC64_ADDR32,        /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          32,                    /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_bitfield, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_PPC64_ADDR32",      /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0xffffffff,            /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* An absolute 26 bit branch; the lower two bits must be zero.
 276      FIXME: we don't check that, we just clear them.  */
 277   HOWTO (R_PPC64_ADDR24,        /* type */
 278          0,                     /* rightshift */
 279          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          26,                    /* bitsize */
 281          FALSE,                 /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_bitfield, /* complain_on_overflow */
 284          bfd_elf_generic_reloc, /* special_function */
 285          "R_PPC64_ADDR24",      /* name */
 286          FALSE,                 /* partial_inplace */
 287          0,                     /* src_mask */
 288          0x03fffffc,            /* dst_mask */
 289          FALSE),                /* pcrel_offset */
 290
 291   /* A standard 16 bit relocation.  */
 292   HOWTO (R_PPC64_ADDR16,        /* type */
 293          0,                     /* rightshift */
 294          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 295          16,                    /* bitsize */
 296          FALSE,                 /* pc_relative */
 297          0,                     /* bitpos */
 298          complain_overflow_bitfield, /* complain_on_overflow */
 299          bfd_elf_generic_reloc, /* special_function */
 300          "R_PPC64_ADDR16",      /* name */
 301          FALSE,                 /* partial_inplace */
 302          0,                     /* src_mask */
 303          0xffff,                /* dst_mask */
 304          FALSE),                /* pcrel_offset */
 305
 306   /* A 16 bit relocation without overflow.  */
 307   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 308          0,                     /* rightshift */
 309          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          16,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_dont,/* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_PPC64_ADDR16_LO",   /* name */
 316          FALSE,                 /* partial_inplace */
 317          0,                     /* src_mask */
 318          0xffff,                /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* Bits 16-31 of an address.  */
 322   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 323          16,                    /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_signed, /* complain_on_overflow */
 329          bfd_elf_generic_reloc, /* special_function */
 330          "R_PPC64_ADDR16_HI",   /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 337      bits, treated as a signed number, is negative.  */
 338   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 339          16,                    /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_signed, /* complain_on_overflow */
 345          ppc64_elf_ha_reloc,    /* special_function */
 346          "R_PPC64_ADDR16_HA",   /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0xffff,                /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* An absolute 16 bit branch; the lower two bits must be zero.
 353      FIXME: we don't check that, we just clear them.  */
 354   HOWTO (R_PPC64_ADDR14,        /* type */
 355          0,                     /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          16,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_signed, /* complain_on_overflow */
 361          ppc64_elf_branch_reloc, /* special_function */
 362          "R_PPC64_ADDR14",      /* name */
 363          FALSE,                 /* partial_inplace */
 364          0,                     /* src_mask */
 365          0x0000fffc,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* An absolute 16 bit branch, for which bit 10 should be set to
 369      indicate that the branch is expected to be taken.  The lower two
 370      bits must be zero.  */
 371   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 372          0,                     /* rightshift */
 373          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 374          16,                    /* bitsize */
 375          FALSE,                 /* pc_relative */
 376          0,                     /* bitpos */
 377          complain_overflow_signed, /* complain_on_overflow */
 378          ppc64_elf_brtaken_reloc, /* special_function */
 379          "R_PPC64_ADDR14_BRTAKEN",/* name */
 380          FALSE,                 /* partial_inplace */
 381          0,                     /* src_mask */
 382          0x0000fffc,            /* dst_mask */
 383          FALSE),                /* pcrel_offset */
 384
 385   /* An absolute 16 bit branch, for which bit 10 should be set to
 386      indicate that the branch is not expected to be taken.  The lower
 387      two bits must be zero.  */
 388   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 389          0,                     /* rightshift */
 390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 391          16,                    /* bitsize */
 392          FALSE,                 /* pc_relative */
 393          0,                     /* bitpos */
 394          complain_overflow_signed, /* complain_on_overflow */
 395          ppc64_elf_brtaken_reloc, /* special_function */
 396          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 397          FALSE,                 /* partial_inplace */
 398          0,                     /* src_mask */
 399          0x0000fffc,            /* dst_mask */
 400          FALSE),                /* pcrel_offset */
 401
 402   /* A relative 26 bit branch; the lower two bits must be zero.  */
 403   HOWTO (R_PPC64_REL24,         /* type */
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          26,                    /* bitsize */
 407          TRUE,                  /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_signed, /* complain_on_overflow */
 410          ppc64_elf_branch_reloc, /* special_function */
 411          "R_PPC64_REL24",       /* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x03fffffc,            /* dst_mask */
 415          TRUE),                 /* pcrel_offset */
 416
 417   /* A relative 16 bit branch; the lower two bits must be zero.  */
 418   HOWTO (R_PPC64_REL14,         /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          16,                    /* bitsize */
 422          TRUE,                  /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          ppc64_elf_branch_reloc, /* special_function */
 426          "R_PPC64_REL14",       /* name */
 427          FALSE,                 /* partial_inplace */
 428          0,                     /* src_mask */
 429          0x0000fffc,            /* dst_mask */
 430          TRUE),                 /* pcrel_offset */
 431
 432   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 433      the branch is expected to be taken.  The lower two bits must be
 434      zero.  */
 435   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 436          0,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          16,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_signed, /* complain_on_overflow */
 442          ppc64_elf_brtaken_reloc, /* special_function */
 443          "R_PPC64_REL14_BRTAKEN", /* name */
 444          FALSE,                 /* partial_inplace */
 445          0,                     /* src_mask */
 446          0x0000fffc,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 450      the branch is not expected to be taken.  The lower two bits must
 451      be zero.  */
 452   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 453          0,                     /* rightshift */
 454          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          16,                    /* bitsize */
 456          TRUE,                  /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_signed, /* complain_on_overflow */
 459          ppc64_elf_brtaken_reloc, /* special_function */
 460          "R_PPC64_REL14_BRNTAKEN",/* name */
 461          FALSE,                 /* partial_inplace */
 462          0,                     /* src_mask */
 463          0x0000fffc,            /* dst_mask */
 464          TRUE),                 /* pcrel_offset */
 465
 466   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 467      symbol.  */
 468   HOWTO (R_PPC64_GOT16,         /* type */
 469          0,                     /* rightshift */
 470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_signed, /* complain_on_overflow */
 475          ppc64_elf_unhandled_reloc, /* special_function */
 476          "R_PPC64_GOT16",       /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0xffff,                /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 483      the symbol.  */
 484   HOWTO (R_PPC64_GOT16_LO,      /* type */
 485          0,                     /* rightshift */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont, /* complain_on_overflow */
 491          ppc64_elf_unhandled_reloc, /* special_function */
 492          "R_PPC64_GOT16_LO",    /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0xffff,                /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 499      the symbol.  */
 500   HOWTO (R_PPC64_GOT16_HI,      /* type */
 501          16,                    /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_signed,/* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16_HI",    /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 515      the symbol.  */
 516   HOWTO (R_PPC64_GOT16_HA,      /* type */
 517          16,                    /* rightshift */
 518          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          16,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_signed,/* complain_on_overflow */
 523          ppc64_elf_unhandled_reloc, /* special_function */
 524          "R_PPC64_GOT16_HA",    /* name */
 525          FALSE,                 /* partial_inplace */
 526          0,                     /* src_mask */
 527          0xffff,                /* dst_mask */
 528          FALSE),                /* pcrel_offset */
 529
 530   /* This is used only by the dynamic linker.  The symbol should exist
 531      both in the object being run and in some shared library.  The
 532      dynamic linker copies the data addressed by the symbol from the
 533      shared library into the object, because the object being
 534      run has to have the data at some particular address.  */
 535   HOWTO (R_PPC64_COPY,          /* type */
 536          0,                     /* rightshift */
 537          0,                     /* this one is variable size */
 538          0,                     /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_dont, /* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc, /* special_function */
 543          "R_PPC64_COPY",        /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          0,                     /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* Like R_PPC64_ADDR64, but used when setting global offset table
 550      entries.  */
 551   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 552          0,                     /* rightshift */
 553          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 554          64,                    /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont, /* complain_on_overflow */
 558          ppc64_elf_unhandled_reloc,  /* special_function */
 559          "R_PPC64_GLOB_DAT",    /* name */
 560          FALSE,                 /* partial_inplace */
 561          0,                     /* src_mask */
 562          ONES (64),             /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564
 565   /* Created by the link editor.  Marks a procedure linkage table
 566      entry for a symbol.  */
 567   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 568          0,                     /* rightshift */
 569          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 570          0,                     /* bitsize */
 571          FALSE,                 /* pc_relative */
 572          0,                     /* bitpos */
 573          complain_overflow_dont, /* complain_on_overflow */
 574          ppc64_elf_unhandled_reloc, /* special_function */
 575          "R_PPC64_JMP_SLOT",    /* name */
 576          FALSE,                 /* partial_inplace */
 577          0,                     /* src_mask */
 578          0,                     /* dst_mask */
 579          FALSE),                /* pcrel_offset */
 580
 581   /* Used only by the dynamic linker.  When the object is run, this
 582      doubleword64 is set to the load address of the object, plus the
 583      addend.  */
 584   HOWTO (R_PPC64_RELATIVE,      /* type */
 585          0,                     /* rightshift */
 586          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 587          64,                    /* bitsize */
 588          FALSE,                 /* pc_relative */
 589          0,                     /* bitpos */
 590          complain_overflow_dont, /* complain_on_overflow */
 591          bfd_elf_generic_reloc, /* special_function */
 592          "R_PPC64_RELATIVE",    /* name */
 593          FALSE,                 /* partial_inplace */
 594          0,                     /* src_mask */
 595          ONES (64),             /* dst_mask */
 596          FALSE),                /* pcrel_offset */
 597
 598   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 599   HOWTO (R_PPC64_UADDR32,       /* type */
 600          0,                     /* rightshift */
 601          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 602          32,                    /* bitsize */
 603          FALSE,                 /* pc_relative */
 604          0,                     /* bitpos */
 605          complain_overflow_bitfield, /* complain_on_overflow */
 606          bfd_elf_generic_reloc, /* special_function */
 607          "R_PPC64_UADDR32",     /* name */
 608          FALSE,                 /* partial_inplace */
 609          0,                     /* src_mask */
 610          0xffffffff,            /* dst_mask */
 611          FALSE),                /* pcrel_offset */
 612
 613   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 614   HOWTO (R_PPC64_UADDR16,       /* type */
 615          0,                     /* rightshift */
 616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 617          16,                    /* bitsize */
 618          FALSE,                 /* pc_relative */
 619          0,                     /* bitpos */
 620          complain_overflow_bitfield, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_UADDR16",     /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffff,                /* dst_mask */
 626          FALSE),                /* pcrel_offset */
 627
 628   /* 32-bit PC relative.  */
 629   HOWTO (R_PPC64_REL32,         /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          TRUE,                  /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_signed, /* complain_on_overflow */
 636          bfd_elf_generic_reloc, /* special_function */
 637          "R_PPC64_REL32",       /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          TRUE),                 /* pcrel_offset */
 642
 643   /* 32-bit relocation to the symbol's procedure linkage table.  */
 644   HOWTO (R_PPC64_PLT32,         /* type */
 645          0,                     /* rightshift */
 646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 647          32,                    /* bitsize */
 648          FALSE,                 /* pc_relative */
 649          0,                     /* bitpos */
 650          complain_overflow_bitfield, /* complain_on_overflow */
 651          ppc64_elf_unhandled_reloc, /* special_function */
 652          "R_PPC64_PLT32",       /* name */
 653          FALSE,                 /* partial_inplace */
 654          0,                     /* src_mask */
 655          0xffffffff,            /* dst_mask */
 656          FALSE),                /* pcrel_offset */
 657
 658   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 659      FIXME: R_PPC64_PLTREL32 not supported.  */
 660   HOWTO (R_PPC64_PLTREL32,      /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          32,                    /* bitsize */
 664          TRUE,                  /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_signed, /* complain_on_overflow */
 667          bfd_elf_generic_reloc, /* special_function */
 668          "R_PPC64_PLTREL32",    /* name */
 669          FALSE,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0xffffffff,            /* dst_mask */
 672          TRUE),                 /* pcrel_offset */
 673
 674   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 675      the symbol.  */
 676   HOWTO (R_PPC64_PLT16_LO,      /* type */
 677          0,                     /* rightshift */
 678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          16,                    /* bitsize */
 680          FALSE,                 /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_dont, /* complain_on_overflow */
 683          ppc64_elf_unhandled_reloc, /* special_function */
 684          "R_PPC64_PLT16_LO",    /* name */
 685          FALSE,                 /* partial_inplace */
 686          0,                     /* src_mask */
 687          0xffff,                /* dst_mask */
 688          FALSE),                /* pcrel_offset */
 689
 690   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 691      the symbol.  */
 692   HOWTO (R_PPC64_PLT16_HI,      /* type */
 693          16,                    /* rightshift */
 694          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          16,                    /* bitsize */
 696          FALSE,                 /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_signed, /* complain_on_overflow */
 699          ppc64_elf_unhandled_reloc, /* special_function */
 700          "R_PPC64_PLT16_HI",    /* name */
 701          FALSE,                 /* partial_inplace */
 702          0,                     /* src_mask */
 703          0xffff,                /* dst_mask */
 704          FALSE),                /* pcrel_offset */
 705
 706   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 707      the symbol.  */
 708   HOWTO (R_PPC64_PLT16_HA,      /* type */
 709          16,                    /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_signed, /* complain_on_overflow */
 715          ppc64_elf_unhandled_reloc, /* special_function */
 716          "R_PPC64_PLT16_HA",    /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* 16-bit section relative relocation.  */
 723   HOWTO (R_PPC64_SECTOFF,       /* type */
 724          0,                     /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_signed, /* complain_on_overflow */
 730          ppc64_elf_sectoff_reloc, /* special_function */
 731          "R_PPC64_SECTOFF",     /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 738   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 739          0,                     /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF_LO",  /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit upper half section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 754          16,                    /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_signed, /* complain_on_overflow */
 760          ppc64_elf_sectoff_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_HI",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* 16-bit upper half adjusted section relative relocation.  */
 768   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 769          16,                    /* rightshift */
 770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          16,                    /* bitsize */
 772          FALSE,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_signed, /* complain_on_overflow */
 775          ppc64_elf_sectoff_ha_reloc, /* special_function */
 776          "R_PPC64_SECTOFF_HA",  /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xffff,                /* dst_mask */
 780          FALSE),                /* pcrel_offset */
 781
 782   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 783   HOWTO (R_PPC64_REL30,         /* type */
 784          2,                     /* rightshift */
 785          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 786          30,                    /* bitsize */
 787          TRUE,                  /* pc_relative */
 788          0,                     /* bitpos */
 789          complain_overflow_dont, /* complain_on_overflow */
 790          bfd_elf_generic_reloc, /* special_function */
 791          "R_PPC64_REL30",       /* name */
 792          FALSE,                 /* partial_inplace */
 793          0,                     /* src_mask */
 794          0xfffffffc,            /* dst_mask */
 795          TRUE),                 /* pcrel_offset */
 796
 797   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 798
 799   /* A standard 64-bit relocation.  */
 800   HOWTO (R_PPC64_ADDR64,        /* type */
 801          0,                     /* rightshift */
 802          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 803          64,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_PPC64_ADDR64",      /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          ONES (64),             /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* The bits 32-47 of an address.  */
 815   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 816          32,                    /* rightshift */
 817          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 818          16,                    /* bitsize */
 819          FALSE,                 /* pc_relative */
 820          0,                     /* bitpos */
 821          complain_overflow_dont, /* complain_on_overflow */
 822          bfd_elf_generic_reloc, /* special_function */
 823          "R_PPC64_ADDR16_HIGHER", /* name */
 824          FALSE,                 /* partial_inplace */
 825          0,                     /* src_mask */
 826          0xffff,                /* dst_mask */
 827          FALSE),                /* pcrel_offset */
 828
 829   /* The bits 32-47 of an address, plus 1 if the contents of the low
 830      16 bits, treated as a signed number, is negative.  */
 831   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 832          32,                    /* rightshift */
 833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 834          16,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          ppc64_elf_ha_reloc,    /* special_function */
 839          "R_PPC64_ADDR16_HIGHERA", /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          0xffff,                /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 48-63 of an address.  */
 846   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 847          48,                    /* rightshift */
 848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 849          16,                    /* bitsize */
 850          FALSE,                 /* pc_relative */
 851          0,                     /* bitpos */
 852          complain_overflow_dont, /* complain_on_overflow */
 853          bfd_elf_generic_reloc, /* special_function */
 854          "R_PPC64_ADDR16_HIGHEST", /* name */
 855          FALSE,                 /* partial_inplace */
 856          0,                     /* src_mask */
 857          0xffff,                /* dst_mask */
 858          FALSE),                /* pcrel_offset */
 859
 860   /* The bits 48-63 of an address, plus 1 if the contents of the low
 861      16 bits, treated as a signed number, is negative.  */
 862   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 863          48,                    /* rightshift */
 864          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 865          16,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          ppc64_elf_ha_reloc,    /* special_function */
 870          "R_PPC64_ADDR16_HIGHESTA", /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          0xffff,                /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* Like ADDR64, but may be unaligned.  */
 877   HOWTO (R_PPC64_UADDR64,       /* type */
 878          0,                     /* rightshift */
 879          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 880          64,                    /* bitsize */
 881          FALSE,                 /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_UADDR64",     /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          ONES (64),             /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* 64-bit relative relocation.  */
 892   HOWTO (R_PPC64_REL64,         /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          TRUE,                  /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_PPC64_REL64",       /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          TRUE),                 /* pcrel_offset */
 905
 906   /* 64-bit relocation to the symbol's procedure linkage table.  */
 907   HOWTO (R_PPC64_PLT64,         /* type */
 908          0,                     /* rightshift */
 909          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 910          64,                    /* bitsize */
 911          FALSE,                 /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont, /* complain_on_overflow */
 914          ppc64_elf_unhandled_reloc, /* special_function */
 915          "R_PPC64_PLT64",       /* name */
 916          FALSE,                 /* partial_inplace */
 917          0,                     /* src_mask */
 918          ONES (64),             /* dst_mask */
 919          FALSE),                /* pcrel_offset */
 920
 921   /* 64-bit PC relative relocation to the symbol's procedure linkage
 922      table.  */
 923   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 924   HOWTO (R_PPC64_PLTREL64,      /* type */
 925          0,                     /* rightshift */
 926          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 927          64,                    /* bitsize */
 928          TRUE,                  /* pc_relative */
 929          0,                     /* bitpos */
 930          complain_overflow_dont, /* complain_on_overflow */
 931          ppc64_elf_unhandled_reloc, /* special_function */
 932          "R_PPC64_PLTREL64",    /* name */
 933          FALSE,                 /* partial_inplace */
 934          0,                     /* src_mask */
 935          ONES (64),             /* dst_mask */
 936          TRUE),                 /* pcrel_offset */
 937
 938   /* 16 bit TOC-relative relocation.  */
 939
 940   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 941   HOWTO (R_PPC64_TOC16,         /* type */
 942          0,                     /* rightshift */
 943          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 944          16,                    /* bitsize */
 945          FALSE,                 /* pc_relative */
 946          0,                     /* bitpos */
 947          complain_overflow_signed, /* complain_on_overflow */
 948          ppc64_elf_toc_reloc,   /* special_function */
 949          "R_PPC64_TOC16",       /* name */
 950          FALSE,                 /* partial_inplace */
 951          0,                     /* src_mask */
 952          0xffff,                /* dst_mask */
 953          FALSE),                /* pcrel_offset */
 954
 955   /* 16 bit TOC-relative relocation without overflow.  */
 956
 957   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 958   HOWTO (R_PPC64_TOC16_LO,      /* type */
 959          0,                     /* rightshift */
 960          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 961          16,                    /* bitsize */
 962          FALSE,                 /* pc_relative */
 963          0,                     /* bitpos */
 964          complain_overflow_dont, /* complain_on_overflow */
 965          ppc64_elf_toc_reloc,   /* special_function */
 966          "R_PPC64_TOC16_LO",    /* name */
 967          FALSE,                 /* partial_inplace */
 968          0,                     /* src_mask */
 969          0xffff,                /* dst_mask */
 970          FALSE),                /* pcrel_offset */
 971
 972   /* 16 bit TOC-relative relocation, high 16 bits.  */
 973
 974   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 975   HOWTO (R_PPC64_TOC16_HI,      /* type */
 976          16,                    /* rightshift */
 977          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 978          16,                    /* bitsize */
 979          FALSE,                 /* pc_relative */
 980          0,                     /* bitpos */
 981          complain_overflow_signed, /* complain_on_overflow */
 982          ppc64_elf_toc_reloc,   /* special_function */
 983          "R_PPC64_TOC16_HI",    /* name */
 984          FALSE,                 /* partial_inplace */
 985          0,                     /* src_mask */
 986          0xffff,                /* dst_mask */
 987          FALSE),                /* pcrel_offset */
 988
 989   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 990      contents of the low 16 bits, treated as a signed number, is
 991      negative.  */
 992
 993   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 994   HOWTO (R_PPC64_TOC16_HA,      /* type */
 995          16,                    /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_toc_ha_reloc, /* special_function */
1002          "R_PPC64_TOC16_HA",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1009
1010   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1011   HOWTO (R_PPC64_TOC,           /* type */
1012          0,                     /* rightshift */
1013          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1014          64,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_dont, /* complain_on_overflow */
1018          ppc64_elf_toc64_reloc, /* special_function */
1019          "R_PPC64_TOC",         /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          ONES (64),             /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_GOT16, but also informs the link editor that the
1026      value to relocate may (!) refer to a PLT entry which the link
1027      editor (a) may replace with the symbol value.  If the link editor
1028      is unable to fully resolve the symbol, it may (b) create a PLT
1029      entry and store the address to the new PLT entry in the GOT.
1030      This permits lazy resolution of function symbols at run time.
1031      The link editor may also skip all of this and just (c) emit a
1032      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1033   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1034     HOWTO (R_PPC64_PLTGOT16,    /* type */
1035          0,                     /* rightshift */
1036          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1037          16,                    /* bitsize */
1038          FALSE,                 /* pc_relative */
1039          0,                     /* bitpos */
1040          complain_overflow_signed, /* complain_on_overflow */
1041          ppc64_elf_unhandled_reloc, /* special_function */
1042          "R_PPC64_PLTGOT16",    /* name */
1043          FALSE,                 /* partial_inplace */
1044          0,                     /* src_mask */
1045          0xffff,                /* dst_mask */
1046          FALSE),                /* pcrel_offset */
1047
1048   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1049   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1050   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1051          0,                     /* rightshift */
1052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1053          16,                    /* bitsize */
1054          FALSE,                 /* pc_relative */
1055          0,                     /* bitpos */
1056          complain_overflow_dont, /* complain_on_overflow */
1057          ppc64_elf_unhandled_reloc, /* special_function */
1058          "R_PPC64_PLTGOT16_LO", /* name */
1059          FALSE,                 /* partial_inplace */
1060          0,                     /* src_mask */
1061          0xffff,                /* dst_mask */
1062          FALSE),                /* pcrel_offset */
1063
1064   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1065   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1066   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1067          16,                    /* rightshift */
1068          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1069          16,                    /* bitsize */
1070          FALSE,                 /* pc_relative */
1071          0,                     /* bitpos */
1072          complain_overflow_signed, /* complain_on_overflow */
1073          ppc64_elf_unhandled_reloc, /* special_function */
1074          "R_PPC64_PLTGOT16_HI", /* name */
1075          FALSE,                 /* partial_inplace */
1076          0,                     /* src_mask */
1077          0xffff,                /* dst_mask */
1078          FALSE),                /* pcrel_offset */
1079
1080   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1081      1 if the contents of the low 16 bits, treated as a signed number,
1082      is negative.  */
1083   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1084   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1085          16,                    /* rightshift */
1086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          16,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_signed, /* complain_on_overflow */
1091          ppc64_elf_unhandled_reloc, /* special_function */
1092          "R_PPC64_PLTGOT16_HA", /* name */
1093          FALSE,                 /* partial_inplace */
1094          0,                     /* src_mask */
1095          0xffff,                /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1099   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1100          0,                     /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_signed, /* complain_on_overflow */
1106          bfd_elf_generic_reloc, /* special_function */
1107          "R_PPC64_ADDR16_DS",   /* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xfffc,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_dont,/* complain_on_overflow */
1121          bfd_elf_generic_reloc, /* special_function */
1122          "R_PPC64_ADDR16_LO_DS",/* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_GOT16_DS,      /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_signed, /* complain_on_overflow */
1136          ppc64_elf_unhandled_reloc, /* special_function */
1137          "R_PPC64_GOT16_DS",    /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_GOT16_LO_DS", /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_dont, /* complain_on_overflow */
1166          ppc64_elf_unhandled_reloc, /* special_function */
1167          "R_PPC64_PLT16_LO_DS", /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_signed, /* complain_on_overflow */
1181          ppc64_elf_sectoff_reloc, /* special_function */
1182          "R_PPC64_SECTOFF_DS",  /* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont, /* complain_on_overflow */
1196          ppc64_elf_sectoff_reloc, /* special_function */
1197          "R_PPC64_SECTOFF_LO_DS",/* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_TOC16_DS,      /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_signed, /* complain_on_overflow */
1211          ppc64_elf_toc_reloc,   /* special_function */
1212          "R_PPC64_TOC16_DS",    /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1219   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1220          0,                     /* rightshift */
1221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          16,                    /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont, /* complain_on_overflow */
1226          ppc64_elf_toc_reloc,   /* special_function */
1227          "R_PPC64_TOC16_LO_DS", /* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0xfffc,                /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1234   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1235   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1236          0,                     /* rightshift */
1237          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1238          16,                    /* bitsize */
1239          FALSE,                 /* pc_relative */
1240          0,                     /* bitpos */
1241          complain_overflow_signed, /* complain_on_overflow */
1242          ppc64_elf_unhandled_reloc, /* special_function */
1243          "R_PPC64_PLTGOT16_DS", /* name */
1244          FALSE,                 /* partial_inplace */
1245          0,                     /* src_mask */
1246          0xfffc,                /* dst_mask */
1247          FALSE),                /* pcrel_offset */
1248
1249   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1250   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1251   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1252          0,                     /* rightshift */
1253          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          16,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          ppc64_elf_unhandled_reloc, /* special_function */
1259          "R_PPC64_PLTGOT16_LO_DS",/* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0xfffc,                /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   /* Marker relocs for TLS.  */
1266   HOWTO (R_PPC64_TLS,
1267          0,                     /* rightshift */
1268          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1269          32,                    /* bitsize */
1270          FALSE,                 /* pc_relative */
1271          0,                     /* bitpos */
1272          complain_overflow_dont, /* complain_on_overflow */
1273          bfd_elf_generic_reloc, /* special_function */
1274          "R_PPC64_TLS",         /* name */
1275          FALSE,                 /* partial_inplace */
1276          0,                     /* src_mask */
1277          0,                     /* dst_mask */
1278          FALSE),                /* pcrel_offset */
1279
1280   HOWTO (R_PPC64_TLSGD,
1281          0,                     /* rightshift */
1282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1283          32,                    /* bitsize */
1284          FALSE,                 /* pc_relative */
1285          0,                     /* bitpos */
1286          complain_overflow_dont, /* complain_on_overflow */
1287          bfd_elf_generic_reloc, /* special_function */
1288          "R_PPC64_TLSGD",       /* name */
1289          FALSE,                 /* partial_inplace */
1290          0,                     /* src_mask */
1291          0,                     /* dst_mask */
1292          FALSE),                /* pcrel_offset */
1293
1294   HOWTO (R_PPC64_TLSLD,
1295          0,                     /* rightshift */
1296          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1297          32,                    /* bitsize */
1298          FALSE,                 /* pc_relative */
1299          0,                     /* bitpos */
1300          complain_overflow_dont, /* complain_on_overflow */
1301          bfd_elf_generic_reloc, /* special_function */
1302          "R_PPC64_TLSLD",       /* name */
1303          FALSE,                 /* partial_inplace */
1304          0,                     /* src_mask */
1305          0,                     /* dst_mask */
1306          FALSE),                /* pcrel_offset */
1307
1308   HOWTO (R_PPC64_TOCSAVE,
1309          0,                     /* rightshift */
1310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1311          32,                    /* bitsize */
1312          FALSE,                 /* pc_relative */
1313          0,                     /* bitpos */
1314          complain_overflow_dont, /* complain_on_overflow */
1315          bfd_elf_generic_reloc, /* special_function */
1316          "R_PPC64_TOCSAVE",     /* name */
1317          FALSE,                 /* partial_inplace */
1318          0,                     /* src_mask */
1319          0,                     /* dst_mask */
1320          FALSE),                /* pcrel_offset */
1321
1322   /* Computes the load module index of the load module that contains the
1323      definition of its TLS sym.  */
1324   HOWTO (R_PPC64_DTPMOD64,
1325          0,                     /* rightshift */
1326          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1327          64,                    /* bitsize */
1328          FALSE,                 /* pc_relative */
1329          0,                     /* bitpos */
1330          complain_overflow_dont, /* complain_on_overflow */
1331          ppc64_elf_unhandled_reloc, /* special_function */
1332          "R_PPC64_DTPMOD64",    /* name */
1333          FALSE,                 /* partial_inplace */
1334          0,                     /* src_mask */
1335          ONES (64),             /* dst_mask */
1336          FALSE),                /* pcrel_offset */
1337
1338   /* Computes a dtv-relative displacement, the difference between the value
1339      of sym+add and the base address of the thread-local storage block that
1340      contains the definition of sym, minus 0x8000.  */
1341   HOWTO (R_PPC64_DTPREL64,
1342          0,                     /* rightshift */
1343          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          64,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont, /* complain_on_overflow */
1348          ppc64_elf_unhandled_reloc, /* special_function */
1349          "R_PPC64_DTPREL64",    /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          ONES (64),             /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* A 16 bit dtprel reloc.  */
1356   HOWTO (R_PPC64_DTPREL16,
1357          0,                     /* rightshift */
1358          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          16,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_signed, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL16",    /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0xffff,                /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* Like DTPREL16, but no overflow.  */
1371   HOWTO (R_PPC64_DTPREL16_LO,
1372          0,                     /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16_LO", /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1386   HOWTO (R_PPC64_DTPREL16_HI,
1387          16,                    /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_signed, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_HI", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HA,
1402          16,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_signed, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HA", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HIGHER,
1417          32,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_dont, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HIGHER", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1432          32,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHERA", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1447          48,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHEST", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1461   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1462          48,                    /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_dont, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xffff,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16, but for insns with a DS field.  */
1476   HOWTO (R_PPC64_DTPREL16_DS,
1477          0,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_signed, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_DS", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xfffc,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Like DTPREL16_DS, but no overflow.  */
1491   HOWTO (R_PPC64_DTPREL16_LO_DS,
1492          0,                     /* rightshift */
1493          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          16,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_dont, /* complain_on_overflow */
1498          ppc64_elf_unhandled_reloc, /* special_function */
1499          "R_PPC64_DTPREL16_LO_DS", /* name */
1500          FALSE,                 /* partial_inplace */
1501          0,                     /* src_mask */
1502          0xfffc,                /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   /* Computes a tp-relative displacement, the difference between the value of
1506      sym+add and the value of the thread pointer (r13).  */
1507   HOWTO (R_PPC64_TPREL64,
1508          0,                     /* rightshift */
1509          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          64,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_dont, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_TPREL64",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          ONES (64),             /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* A 16 bit tprel reloc.  */
1522   HOWTO (R_PPC64_TPREL16,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_signed, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL16",     /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Like TPREL16, but no overflow.  */
1537   HOWTO (R_PPC64_TPREL16_LO,
1538          0,                     /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16_LO",  /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1552   HOWTO (R_PPC64_TPREL16_HI,
1553          16,                    /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_signed, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_HI",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HA,
1568          16,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_signed, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HA",  /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HIGHER,
1583          32,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_dont, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HIGHER",      /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHERA,
1598          32,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHERA", /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHEST,
1613          48,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHEST", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1627   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1628          48,                    /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_dont, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_HIGHESTA", /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xffff,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16, but for insns with a DS field.  */
1642   HOWTO (R_PPC64_TPREL16_DS,
1643          0,                     /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_signed, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_DS",  /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xfffc,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Like TPREL16_DS, but no overflow.  */
1657   HOWTO (R_PPC64_TPREL16_LO_DS,
1658          0,                     /* rightshift */
1659          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1660          16,                    /* bitsize */
1661          FALSE,                 /* pc_relative */
1662          0,                     /* bitpos */
1663          complain_overflow_dont, /* complain_on_overflow */
1664          ppc64_elf_unhandled_reloc, /* special_function */
1665          "R_PPC64_TPREL16_LO_DS", /* name */
1666          FALSE,                 /* partial_inplace */
1667          0,                     /* src_mask */
1668          0xfffc,                /* dst_mask */
1669          FALSE),                /* pcrel_offset */
1670
1671   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1672      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1673      to the first entry relative to the TOC base (r2).  */
1674   HOWTO (R_PPC64_GOT_TLSGD16,
1675          0,                     /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_signed, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_GOT_TLSGD16", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like GOT_TLSGD16, but no overflow.  */
1689   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1690          0,                     /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16_LO", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1705          16,                    /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_signed, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_HI", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1719   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1720          16,                    /* rightshift */
1721          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1722          16,                    /* bitsize */
1723          FALSE,                 /* pc_relative */
1724          0,                     /* bitpos */
1725          complain_overflow_signed, /* complain_on_overflow */
1726          ppc64_elf_unhandled_reloc, /* special_function */
1727          "R_PPC64_GOT_TLSGD16_HA", /* name */
1728          FALSE,                 /* partial_inplace */
1729          0,                     /* src_mask */
1730          0xffff,                /* dst_mask */
1731          FALSE),                /* pcrel_offset */
1732
1733   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1734      with values (sym+add)@dtpmod and zero, and computes the offset to the
1735      first entry relative to the TOC base (r2).  */
1736   HOWTO (R_PPC64_GOT_TLSLD16,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_signed, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSLD16", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSLD16, but no overflow.  */
1751   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1752          0,                     /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16_LO", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1767          16,                    /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_signed, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_HI", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1781   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1782          16,                    /* rightshift */
1783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1784          16,                    /* bitsize */
1785          FALSE,                 /* pc_relative */
1786          0,                     /* bitpos */
1787          complain_overflow_signed, /* complain_on_overflow */
1788          ppc64_elf_unhandled_reloc, /* special_function */
1789          "R_PPC64_GOT_TLSLD16_HA", /* name */
1790          FALSE,                 /* partial_inplace */
1791          0,                     /* src_mask */
1792          0xffff,                /* dst_mask */
1793          FALSE),                /* pcrel_offset */
1794
1795   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1796      the offset to the entry relative to the TOC base (r2).  */
1797   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1798          0,                     /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_signed, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_DTPREL16_DS", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xfffc,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_DTPREL16_DS, but no overflow.  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1813          0,                     /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_dont, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xfffc,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1828          16,                    /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_signed, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_HI", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xffff,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1842   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1843          16,                    /* rightshift */
1844          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1845          16,                    /* bitsize */
1846          FALSE,                 /* pc_relative */
1847          0,                     /* bitpos */
1848          complain_overflow_signed, /* complain_on_overflow */
1849          ppc64_elf_unhandled_reloc, /* special_function */
1850          "R_PPC64_GOT_DTPREL16_HA", /* name */
1851          FALSE,                 /* partial_inplace */
1852          0,                     /* src_mask */
1853          0xffff,                /* dst_mask */
1854          FALSE),                /* pcrel_offset */
1855
1856   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1857      offset to the entry relative to the TOC base (r2).  */
1858   HOWTO (R_PPC64_GOT_TPREL16_DS,
1859          0,                     /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_signed, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_TPREL16_DS", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xfffc,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_TPREL16_DS, but no overflow.  */
1873   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1874          0,                     /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_dont, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xfffc,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_HI,
1889          16,                    /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_signed, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_HI", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xffff,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1903   HOWTO (R_PPC64_GOT_TPREL16_HA,
1904          16,                    /* rightshift */
1905          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1906          16,                    /* bitsize */
1907          FALSE,                 /* pc_relative */
1908          0,                     /* bitpos */
1909          complain_overflow_signed, /* complain_on_overflow */
1910          ppc64_elf_unhandled_reloc, /* special_function */
1911          "R_PPC64_GOT_TPREL16_HA", /* name */
1912          FALSE,                 /* partial_inplace */
1913          0,                     /* src_mask */
1914          0xffff,                /* dst_mask */
1915          FALSE),                /* pcrel_offset */
1916
1917   HOWTO (R_PPC64_JMP_IREL,      /* type */
1918          0,                     /* rightshift */
1919          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1920          0,                     /* bitsize */
1921          FALSE,                 /* pc_relative */
1922          0,                     /* bitpos */
1923          complain_overflow_dont, /* complain_on_overflow */
1924          ppc64_elf_unhandled_reloc, /* special_function */
1925          "R_PPC64_JMP_IREL",    /* name */
1926          FALSE,                 /* partial_inplace */
1927          0,                     /* src_mask */
1928          0,                     /* dst_mask */
1929          FALSE),                /* pcrel_offset */
1930
1931   HOWTO (R_PPC64_IRELATIVE,     /* type */
1932          0,                     /* rightshift */
1933          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1934          64,                    /* bitsize */
1935          FALSE,                 /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_dont, /* complain_on_overflow */
1938          bfd_elf_generic_reloc, /* special_function */
1939          "R_PPC64_IRELATIVE",   /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          ONES (64),             /* dst_mask */
1943          FALSE),                /* pcrel_offset */
1944
1945   /* A 16 bit relative relocation.  */
1946   HOWTO (R_PPC64_REL16,         /* type */
1947          0,                     /* rightshift */
1948          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1949          16,                    /* bitsize */
1950          TRUE,                  /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_signed, /* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_REL16",       /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          0xffff,                /* dst_mask */
1958          TRUE),                 /* pcrel_offset */
1959
1960   /* A 16 bit relative relocation without overflow.  */
1961   HOWTO (R_PPC64_REL16_LO,      /* type */
1962          0,                     /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont,/* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16_LO",    /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* The high order 16 bits of a relative address.  */
1976   HOWTO (R_PPC64_REL16_HI,      /* type */
1977          16,                    /* rightshift */
1978          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1979          16,                    /* bitsize */
1980          TRUE,                  /* pc_relative */
1981          0,                     /* bitpos */
1982          complain_overflow_signed, /* complain_on_overflow */
1983          bfd_elf_generic_reloc, /* special_function */
1984          "R_PPC64_REL16_HI",    /* name */
1985          FALSE,                 /* partial_inplace */
1986          0,                     /* src_mask */
1987          0xffff,                /* dst_mask */
1988          TRUE),                 /* pcrel_offset */
1989
1990   /* The high order 16 bits of a relative address, plus 1 if the contents of
1991      the low 16 bits, treated as a signed number, is negative.  */
1992   HOWTO (R_PPC64_REL16_HA,      /* type */
1993          16,                    /* rightshift */
1994          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          16,                    /* bitsize */
1996          TRUE,                  /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_signed, /* complain_on_overflow */
1999          ppc64_elf_ha_reloc,    /* special_function */
2000          "R_PPC64_REL16_HA",    /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0xffff,                /* dst_mask */
2004          TRUE),                 /* pcrel_offset */
2005
2006   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2007   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2008          16,                    /* rightshift */
2009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          16,                    /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont, /* complain_on_overflow */
2014          bfd_elf_generic_reloc, /* special_function */
2015          "R_PPC64_ADDR16_HIGH", /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0xffff,                /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020
2021   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2022   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2023          16,                    /* rightshift */
2024          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2025          16,                    /* bitsize */
2026          FALSE,                 /* pc_relative */
2027          0,                     /* bitpos */
2028          complain_overflow_dont, /* complain_on_overflow */
2029          ppc64_elf_ha_reloc,    /* special_function */
2030          "R_PPC64_ADDR16_HIGHA",        /* name */
2031          FALSE,                 /* partial_inplace */
2032          0,                     /* src_mask */
2033          0xffff,                /* dst_mask */
2034          FALSE),                /* pcrel_offset */
2035
2036   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2037   HOWTO (R_PPC64_DTPREL16_HIGH,
2038          16,                    /* rightshift */
2039          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2040          16,                    /* bitsize */
2041          FALSE,                 /* pc_relative */
2042          0,                     /* bitpos */
2043          complain_overflow_dont, /* complain_on_overflow */
2044          ppc64_elf_unhandled_reloc, /* special_function */
2045          "R_PPC64_DTPREL16_HIGH", /* name */
2046          FALSE,                 /* partial_inplace */
2047          0,                     /* src_mask */
2048          0xffff,                /* dst_mask */
2049          FALSE),                /* pcrel_offset */
2050
2051   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2052   HOWTO (R_PPC64_DTPREL16_HIGHA,
2053          16,                    /* rightshift */
2054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2055          16,                    /* bitsize */
2056          FALSE,                 /* pc_relative */
2057          0,                     /* bitpos */
2058          complain_overflow_dont, /* complain_on_overflow */
2059          ppc64_elf_unhandled_reloc, /* special_function */
2060          "R_PPC64_DTPREL16_HIGHA", /* name */
2061          FALSE,                 /* partial_inplace */
2062          0,                     /* src_mask */
2063          0xffff,                /* dst_mask */
2064          FALSE),                /* pcrel_offset */
2065
2066   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2067   HOWTO (R_PPC64_TPREL16_HIGH,
2068          16,                    /* rightshift */
2069          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2070          16,                    /* bitsize */
2071          FALSE,                 /* pc_relative */
2072          0,                     /* bitpos */
2073          complain_overflow_dont, /* complain_on_overflow */
2074          ppc64_elf_unhandled_reloc, /* special_function */
2075          "R_PPC64_TPREL16_HIGH",        /* name */
2076          FALSE,                 /* partial_inplace */
2077          0,                     /* src_mask */
2078          0xffff,                /* dst_mask */
2079          FALSE),                /* pcrel_offset */
2080
2081   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2082   HOWTO (R_PPC64_TPREL16_HIGHA,
2083          16,                    /* rightshift */
2084          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2085          16,                    /* bitsize */
2086          FALSE,                 /* pc_relative */
2087          0,                     /* bitpos */
2088          complain_overflow_dont, /* complain_on_overflow */
2089          ppc64_elf_unhandled_reloc, /* special_function */
2090          "R_PPC64_TPREL16_HIGHA",       /* name */
2091          FALSE,                 /* partial_inplace */
2092          0,                     /* src_mask */
2093          0xffff,                /* dst_mask */
2094          FALSE),                /* pcrel_offset */
2095
2096   /* Like ADDR64, but use local entry point of function.  */
2097   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2098          0,                     /* rightshift */
2099          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2100          64,                    /* bitsize */
2101          FALSE,                 /* pc_relative */
2102          0,                     /* bitpos */
2103          complain_overflow_dont, /* complain_on_overflow */
2104          bfd_elf_generic_reloc, /* special_function */
2105          "R_PPC64_ADDR64_LOCAL", /* name */
2106          FALSE,                 /* partial_inplace */
2107          0,                     /* src_mask */
2108          ONES (64),             /* dst_mask */
2109          FALSE),                /* pcrel_offset */
2110
2111   /* GNU extension to record C++ vtable hierarchy.  */
2112   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2113          0,                     /* rightshift */
2114          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2115          0,                     /* bitsize */
2116          FALSE,                 /* pc_relative */
2117          0,                     /* bitpos */
2118          complain_overflow_dont, /* complain_on_overflow */
2119          NULL,                  /* special_function */
2120          "R_PPC64_GNU_VTINHERIT", /* name */
2121          FALSE,                 /* partial_inplace */
2122          0,                     /* src_mask */
2123          0,                     /* dst_mask */
2124          FALSE),                /* pcrel_offset */
2125
2126   /* GNU extension to record C++ vtable member usage.  */
2127   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2128          0,                     /* rightshift */
2129          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2130          0,                     /* bitsize */
2131          FALSE,                 /* pc_relative */
2132          0,                     /* bitpos */
2133          complain_overflow_dont, /* complain_on_overflow */
2134          NULL,                  /* special_function */
2135          "R_PPC64_GNU_VTENTRY", /* name */
2136          FALSE,                 /* partial_inplace */
2137          0,                     /* src_mask */
2138          0,                     /* dst_mask */
2139          FALSE),                /* pcrel_offset */
2140 };
2141
2142 \f
2143 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2144    be done.  */
2145
2146 static void
2147 ppc_howto_init (void)
2148 {
2149   unsigned int i, type;
2150
2151   for (i = 0;
2152        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2153        i++)
2154     {
2155       type = ppc64_elf_howto_raw[i].type;
2156       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2157                           / sizeof (ppc64_elf_howto_table[0])));
2158       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2159     }
2160 }
2161
2162 static reloc_howto_type *
2163 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2164                              bfd_reloc_code_real_type code)
2165 {
2166   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2167
2168   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2169     /* Initialize howto table if needed.  */
2170     ppc_howto_init ();
2171
2172   switch (code)
2173     {
2174     default:
2175       return NULL;
2176
2177     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2178       break;
2179     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2180       break;
2181     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2182       break;
2183     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2184       break;
2185     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2186       break;
2187     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2188       break;
2189     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2190       break;
2191     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2192       break;
2193     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2194       break;
2195     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2196       break;
2197     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2198       break;
2199     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2200       break;
2201     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2202       break;
2203     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2204       break;
2205     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2206       break;
2207     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2208       break;
2209     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2210       break;
2211     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2212       break;
2213     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2214       break;
2215     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2216       break;
2217     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2218       break;
2219     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2220       break;
2221     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2222       break;
2223     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2224       break;
2225     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2226       break;
2227     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2228       break;
2229     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2230       break;
2231     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2232       break;
2233     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2234       break;
2235     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2236       break;
2237     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2238       break;
2239     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2240       break;
2241     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2242       break;
2243     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2244       break;
2245     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2246       break;
2247     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2248       break;
2249     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2250       break;
2251     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2252       break;
2253     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2254       break;
2255     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2256       break;
2257     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2258       break;
2259     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2260       break;
2261     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2262       break;
2263     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2264       break;
2265     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2266       break;
2267     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2268       break;
2269     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2270       break;
2271     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2272       break;
2273     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2274       break;
2275     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2276       break;
2277     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2278       break;
2279     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2280       break;
2281     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2282       break;
2283     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2284       break;
2285     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2286       break;
2287     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2288       break;
2289     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2290       break;
2291     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2292       break;
2293     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2294       break;
2295     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2296       break;
2297     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2298       break;
2299     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2300       break;
2301     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2302       break;
2303     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2304       break;
2305     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2306       break;
2307     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2308       break;
2309     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2310       break;
2311     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2312       break;
2313     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2314       break;
2315     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2316       break;
2317     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2318       break;
2319     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2320       break;
2321     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2322       break;
2323     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2324       break;
2325     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2326       break;
2327     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2328       break;
2329     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2330       break;
2331     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2332       break;
2333     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2334       break;
2335     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2336       break;
2337     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2338       break;
2339     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2340       break;
2341     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2342       break;
2343     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2344       break;
2345     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2346       break;
2347     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2348       break;
2349     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2350       break;
2351     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2352       break;
2353     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2354       break;
2355     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2356       break;
2357     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2358       break;
2359     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2360       break;
2361     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2362       break;
2363     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2364       break;
2365     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2366       break;
2367     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2368       break;
2369     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2370       break;
2371     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2372       break;
2373     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2374       break;
2375     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2376       break;
2377     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2378       break;
2379     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2380       break;
2381     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2382       break;
2383     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2384       break;
2385     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2386       break;
2387     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2388       break;
2389     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2390       break;
2391     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2392       break;
2393     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2394       break;
2395     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2396       break;
2397     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2398       break;
2399     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2400       break;
2401     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2402       break;
2403     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2404       break;
2405     }
2406
2407   return ppc64_elf_howto_table[r];
2408 };
2409
2410 static reloc_howto_type *
2411 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2412                              const char *r_name)
2413 {
2414   unsigned int i;
2415
2416   for (i = 0;
2417        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2418        i++)
2419     if (ppc64_elf_howto_raw[i].name != NULL
2420         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2421       return &ppc64_elf_howto_raw[i];
2422
2423   return NULL;
2424 }
2425
2426 /* Set the howto pointer for a PowerPC ELF reloc.  */
2427
2428 static void
2429 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2430                          Elf_Internal_Rela *dst)
2431 {
2432   unsigned int type;
2433
2434   /* Initialize howto table if needed.  */
2435   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2436     ppc_howto_init ();
2437
2438   type = ELF64_R_TYPE (dst->r_info);
2439   if (type >= (sizeof (ppc64_elf_howto_table)
2440                / sizeof (ppc64_elf_howto_table[0])))
2441     {
2442       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2443                              abfd, (int) type);
2444       type = R_PPC64_NONE;
2445     }
2446   cache_ptr->howto = ppc64_elf_howto_table[type];
2447 }
2448
2449 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2450
2451 static bfd_reloc_status_type
2452 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453                     void *data, asection *input_section,
2454                     bfd *output_bfd, char **error_message)
2455 {
2456   /* If this is a relocatable link (output_bfd test tells us), just
2457      call the generic function.  Any adjustment will be done at final
2458      link time.  */
2459   if (output_bfd != NULL)
2460     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2461                                   input_section, output_bfd, error_message);
2462
2463   /* Adjust the addend for sign extension of the low 16 bits.
2464      We won't actually be using the low 16 bits, so trashing them
2465      doesn't matter.  */
2466   reloc_entry->addend += 0x8000;
2467   return bfd_reloc_continue;
2468 }
2469
2470 static bfd_reloc_status_type
2471 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2472                         void *data, asection *input_section,
2473                         bfd *output_bfd, char **error_message)
2474 {
2475   if (output_bfd != NULL)
2476     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2477                                   input_section, output_bfd, error_message);
2478
2479   if (strcmp (symbol->section->name, ".opd") == 0
2480       && (symbol->section->owner->flags & DYNAMIC) == 0)
2481     {
2482       bfd_vma dest = opd_entry_value (symbol->section,
2483                                       symbol->value + reloc_entry->addend,
2484                                       NULL, NULL, FALSE);
2485       if (dest != (bfd_vma) -1)
2486         reloc_entry->addend = dest - (symbol->value
2487                                       + symbol->section->output_section->vma
2488                                       + symbol->section->output_offset);
2489     }
2490   return bfd_reloc_continue;
2491 }
2492
2493 static bfd_reloc_status_type
2494 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2495                          void *data, asection *input_section,
2496                          bfd *output_bfd, char **error_message)
2497 {
2498   long insn;
2499   enum elf_ppc64_reloc_type r_type;
2500   bfd_size_type octets;
2501   /* Assume 'at' branch hints.  */
2502   bfd_boolean is_isa_v2 = TRUE;
2503
2504   /* If this is a relocatable link (output_bfd test tells us), just
2505      call the generic function.  Any adjustment will be done at final
2506      link time.  */
2507   if (output_bfd != NULL)
2508     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2509                                   input_section, output_bfd, error_message);
2510
2511   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2512   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2513   insn &= ~(0x01 << 21);
2514   r_type = reloc_entry->howto->type;
2515   if (r_type == R_PPC64_ADDR14_BRTAKEN
2516       || r_type == R_PPC64_REL14_BRTAKEN)
2517     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2518
2519   if (is_isa_v2)
2520     {
2521       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2522          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2523          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2524       if ((insn & (0x14 << 21)) == (0x04 << 21))
2525         insn |= 0x02 << 21;
2526       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2527         insn |= 0x08 << 21;
2528       else
2529         goto out;
2530     }
2531   else
2532     {
2533       bfd_vma target = 0;
2534       bfd_vma from;
2535
2536       if (!bfd_is_com_section (symbol->section))
2537         target = symbol->value;
2538       target += symbol->section->output_section->vma;
2539       target += symbol->section->output_offset;
2540       target += reloc_entry->addend;
2541
2542       from = (reloc_entry->address
2543               + input_section->output_offset
2544               + input_section->output_section->vma);
2545
2546       /* Invert 'y' bit if not the default.  */
2547       if ((bfd_signed_vma) (target - from) < 0)
2548         insn ^= 0x01 << 21;
2549     }
2550   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2551  out:
2552   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2553                                  input_section, output_bfd, error_message);
2554 }
2555
2556 static bfd_reloc_status_type
2557 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2558                          void *data, asection *input_section,
2559                          bfd *output_bfd, char **error_message)
2560 {
2561   /* If this is a relocatable link (output_bfd test tells us), just
2562      call the generic function.  Any adjustment will be done at final
2563      link time.  */
2564   if (output_bfd != NULL)
2565     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2566                                   input_section, output_bfd, error_message);
2567
2568   /* Subtract the symbol section base address.  */
2569   reloc_entry->addend -= symbol->section->output_section->vma;
2570   return bfd_reloc_continue;
2571 }
2572
2573 static bfd_reloc_status_type
2574 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575                             void *data, asection *input_section,
2576                             bfd *output_bfd, char **error_message)
2577 {
2578   /* If this is a relocatable link (output_bfd test tells us), just
2579      call the generic function.  Any adjustment will be done at final
2580      link time.  */
2581   if (output_bfd != NULL)
2582     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2583                                   input_section, output_bfd, error_message);
2584
2585   /* Subtract the symbol section base address.  */
2586   reloc_entry->addend -= symbol->section->output_section->vma;
2587
2588   /* Adjust the addend for sign extension of the low 16 bits.  */
2589   reloc_entry->addend += 0x8000;
2590   return bfd_reloc_continue;
2591 }
2592
2593 static bfd_reloc_status_type
2594 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2595                      void *data, asection *input_section,
2596                      bfd *output_bfd, char **error_message)
2597 {
2598   bfd_vma TOCstart;
2599
2600   /* If this is a relocatable link (output_bfd test tells us), just
2601      call the generic function.  Any adjustment will be done at final
2602      link time.  */
2603   if (output_bfd != NULL)
2604     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2605                                   input_section, output_bfd, error_message);
2606
2607   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2608   if (TOCstart == 0)
2609     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2610
2611   /* Subtract the TOC base address.  */
2612   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2613   return bfd_reloc_continue;
2614 }
2615
2616 static bfd_reloc_status_type
2617 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2618                         void *data, asection *input_section,
2619                         bfd *output_bfd, char **error_message)
2620 {
2621   bfd_vma TOCstart;
2622
2623   /* If this is a relocatable link (output_bfd test tells us), just
2624      call the generic function.  Any adjustment will be done at final
2625      link time.  */
2626   if (output_bfd != NULL)
2627     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628                                   input_section, output_bfd, error_message);
2629
2630   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2631   if (TOCstart == 0)
2632     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2633
2634   /* Subtract the TOC base address.  */
2635   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2636
2637   /* Adjust the addend for sign extension of the low 16 bits.  */
2638   reloc_entry->addend += 0x8000;
2639   return bfd_reloc_continue;
2640 }
2641
2642 static bfd_reloc_status_type
2643 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2644                        void *data, asection *input_section,
2645                        bfd *output_bfd, char **error_message)
2646 {
2647   bfd_vma TOCstart;
2648   bfd_size_type octets;
2649
2650   /* If this is a relocatable link (output_bfd test tells us), just
2651      call the generic function.  Any adjustment will be done at final
2652      link time.  */
2653   if (output_bfd != NULL)
2654     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2655                                   input_section, output_bfd, error_message);
2656
2657   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2658   if (TOCstart == 0)
2659     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2660
2661   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2662   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2663   return bfd_reloc_ok;
2664 }
2665
2666 static bfd_reloc_status_type
2667 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2668                            void *data, asection *input_section,
2669                            bfd *output_bfd, char **error_message)
2670 {
2671   /* If this is a relocatable link (output_bfd test tells us), just
2672      call the generic function.  Any adjustment will be done at final
2673      link time.  */
2674   if (output_bfd != NULL)
2675     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2676                                   input_section, output_bfd, error_message);
2677
2678   if (error_message != NULL)
2679     {
2680       static char buf[60];
2681       sprintf (buf, "generic linker can't handle %s",
2682                reloc_entry->howto->name);
2683       *error_message = buf;
2684     }
2685   return bfd_reloc_dangerous;
2686 }
2687
2688 /* Track GOT entries needed for a given symbol.  We might need more
2689    than one got entry per symbol.  */
2690 struct got_entry
2691 {
2692   struct got_entry *next;
2693
2694   /* The symbol addend that we'll be placing in the GOT.  */
2695   bfd_vma addend;
2696
2697   /* Unlike other ELF targets, we use separate GOT entries for the same
2698      symbol referenced from different input files.  This is to support
2699      automatic multiple TOC/GOT sections, where the TOC base can vary
2700      from one input file to another.  After partitioning into TOC groups
2701      we merge entries within the group.
2702
2703      Point to the BFD owning this GOT entry.  */
2704   bfd *owner;
2705
2706   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2707      TLS_TPREL or TLS_DTPREL for tls entries.  */
2708   unsigned char tls_type;
2709
2710   /* Non-zero if got.ent points to real entry.  */
2711   unsigned char is_indirect;
2712
2713   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718       struct got_entry *ent;
2719     } got;
2720 };
2721
2722 /* The same for PLT.  */
2723 struct plt_entry
2724 {
2725   struct plt_entry *next;
2726
2727   bfd_vma addend;
2728
2729   union
2730     {
2731       bfd_signed_vma refcount;
2732       bfd_vma offset;
2733     } plt;
2734 };
2735
2736 struct ppc64_elf_obj_tdata
2737 {
2738   struct elf_obj_tdata elf;
2739
2740   /* Shortcuts to dynamic linker sections.  */
2741   asection *got;
2742   asection *relgot;
2743
2744   /* Used during garbage collection.  We attach global symbols defined
2745      on removed .opd entries to this section so that the sym is removed.  */
2746   asection *deleted_section;
2747
2748   /* TLS local dynamic got entry handling.  Support for multiple GOT
2749      sections means we potentially need one of these for each input bfd.  */
2750   struct got_entry tlsld_got;
2751
2752   union {
2753     /* A copy of relocs before they are modified for --emit-relocs.  */
2754     Elf_Internal_Rela *relocs;
2755
2756     /* Section contents.  */
2757     bfd_byte *contents;
2758   } opd;
2759
2760   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2761      the reloc to be in the range -32768 to 32767.  */
2762   unsigned int has_small_toc_reloc : 1;
2763
2764   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2765      instruction not one we handle.  */
2766   unsigned int unexpected_toc_insn : 1;
2767 };
2768
2769 #define ppc64_elf_tdata(bfd) \
2770   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2771
2772 #define ppc64_tlsld_got(bfd) \
2773   (&ppc64_elf_tdata (bfd)->tlsld_got)
2774
2775 #define is_ppc64_elf(bfd) \
2776   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2777    && elf_object_id (bfd) == PPC64_ELF_DATA)
2778
2779 /* Override the generic function because we store some extras.  */
2780
2781 static bfd_boolean
2782 ppc64_elf_mkobject (bfd *abfd)
2783 {
2784   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2785                                   PPC64_ELF_DATA);
2786 }
2787
2788 /* Fix bad default arch selected for a 64 bit input bfd when the
2789    default is 32 bit.  */
2790
2791 static bfd_boolean
2792 ppc64_elf_object_p (bfd *abfd)
2793 {
2794   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2795     {
2796       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2797
2798       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2799         {
2800           /* Relies on arch after 32 bit default being 64 bit default.  */
2801           abfd->arch_info = abfd->arch_info->next;
2802           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2803         }
2804     }
2805   return TRUE;
2806 }
2807
2808 /* Support for core dump NOTE sections.  */
2809
2810 static bfd_boolean
2811 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2812 {
2813   size_t offset, size;
2814
2815   if (note->descsz != 504)
2816     return FALSE;
2817
2818   /* pr_cursig */
2819   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2820
2821   /* pr_pid */
2822   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2823
2824   /* pr_reg */
2825   offset = 112;
2826   size = 384;
2827
2828   /* Make a ".reg/999" section.  */
2829   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2830                                           size, note->descpos + offset);
2831 }
2832
2833 static bfd_boolean
2834 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2835 {
2836   if (note->descsz != 136)
2837     return FALSE;
2838
2839   elf_tdata (abfd)->core->pid
2840     = bfd_get_32 (abfd, note->descdata + 24);
2841   elf_tdata (abfd)->core->program
2842     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2843   elf_tdata (abfd)->core->command
2844     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2845
2846   return TRUE;
2847 }
2848
2849 static char *
2850 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2851                            ...)
2852 {
2853   switch (note_type)
2854     {
2855     default:
2856       return NULL;
2857
2858     case NT_PRPSINFO:
2859       {
2860         char data[136];
2861         va_list ap;
2862
2863         va_start (ap, note_type);
2864         memset (data, 0, sizeof (data));
2865         strncpy (data + 40, va_arg (ap, const char *), 16);
2866         strncpy (data + 56, va_arg (ap, const char *), 80);
2867         va_end (ap);
2868         return elfcore_write_note (abfd, buf, bufsiz,
2869                                    "CORE", note_type, data, sizeof (data));
2870       }
2871
2872     case NT_PRSTATUS:
2873       {
2874         char data[504];
2875         va_list ap;
2876         long pid;
2877         int cursig;
2878         const void *greg;
2879
2880         va_start (ap, note_type);
2881         memset (data, 0, 112);
2882         pid = va_arg (ap, long);
2883         bfd_put_32 (abfd, pid, data + 32);
2884         cursig = va_arg (ap, int);
2885         bfd_put_16 (abfd, cursig, data + 12);
2886         greg = va_arg (ap, const void *);
2887         memcpy (data + 112, greg, 384);
2888         memset (data + 496, 0, 8);
2889         va_end (ap);
2890         return elfcore_write_note (abfd, buf, bufsiz,
2891                                    "CORE", note_type, data, sizeof (data));
2892       }
2893     }
2894 }
2895
2896 /* Add extra PPC sections.  */
2897
2898 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2899 {
2900   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2901   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2902   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2903   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2906   { NULL,                     0,  0, 0,            0 }
2907 };
2908
2909 enum _ppc64_sec_type {
2910   sec_normal = 0,
2911   sec_opd = 1,
2912   sec_toc = 2
2913 };
2914
2915 struct _ppc64_elf_section_data
2916 {
2917   struct bfd_elf_section_data elf;
2918
2919   union
2920   {
2921     /* An array with one entry for each opd function descriptor.  */
2922     struct _opd_sec_data
2923     {
2924       /* Points to the function code section for local opd entries.  */
2925       asection **func_sec;
2926
2927       /* After editing .opd, adjust references to opd local syms.  */
2928       long *adjust;
2929     } opd;
2930
2931     /* An array for toc sections, indexed by offset/8.  */
2932     struct _toc_sec_data
2933     {
2934       /* Specifies the relocation symbol index used at a given toc offset.  */
2935       unsigned *symndx;
2936
2937       /* And the relocation addend.  */
2938       bfd_vma *add;
2939     } toc;
2940   } u;
2941
2942   enum _ppc64_sec_type sec_type:2;
2943
2944   /* Flag set when small branches are detected.  Used to
2945      select suitable defaults for the stub group size.  */
2946   unsigned int has_14bit_branch:1;
2947 };
2948
2949 #define ppc64_elf_section_data(sec) \
2950   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2951
2952 static bfd_boolean
2953 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2954 {
2955   if (!sec->used_by_bfd)
2956     {
2957       struct _ppc64_elf_section_data *sdata;
2958       bfd_size_type amt = sizeof (*sdata);
2959
2960       sdata = bfd_zalloc (abfd, amt);
2961       if (sdata == NULL)
2962         return FALSE;
2963       sec->used_by_bfd = sdata;
2964     }
2965
2966   return _bfd_elf_new_section_hook (abfd, sec);
2967 }
2968
2969 static struct _opd_sec_data *
2970 get_opd_info (asection * sec)
2971 {
2972   if (sec != NULL
2973       && ppc64_elf_section_data (sec) != NULL
2974       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2975     return &ppc64_elf_section_data (sec)->u.opd;
2976   return NULL;
2977 }
2978
2979 static inline int
2980 abiversion (bfd *abfd)
2981 {
2982   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2983 }
2984
2985 static inline void
2986 set_abiversion (bfd *abfd, int ver)
2987 {
2988   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2989   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2990 }
2991 \f
2992 /* Parameters for the qsort hook.  */
2993 static bfd_boolean synthetic_relocatable;
2994
2995 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2996
2997 static int
2998 compare_symbols (const void *ap, const void *bp)
2999 {
3000   const asymbol *a = * (const asymbol **) ap;
3001   const asymbol *b = * (const asymbol **) bp;
3002
3003   /* Section symbols first.  */
3004   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3005     return -1;
3006   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3007     return 1;
3008
3009   /* then .opd symbols.  */
3010   if (strcmp (a->section->name, ".opd") == 0
3011       && strcmp (b->section->name, ".opd") != 0)
3012     return -1;
3013   if (strcmp (a->section->name, ".opd") != 0
3014       && strcmp (b->section->name, ".opd") == 0)
3015     return 1;
3016
3017   /* then other code symbols.  */
3018   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3019       == (SEC_CODE | SEC_ALLOC)
3020       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3021          != (SEC_CODE | SEC_ALLOC))
3022     return -1;
3023
3024   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3025       != (SEC_CODE | SEC_ALLOC)
3026       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3027          == (SEC_CODE | SEC_ALLOC))
3028     return 1;
3029
3030   if (synthetic_relocatable)
3031     {
3032       if (a->section->id < b->section->id)
3033         return -1;
3034
3035       if (a->section->id > b->section->id)
3036         return 1;
3037     }
3038
3039   if (a->value + a->section->vma < b->value + b->section->vma)
3040     return -1;
3041
3042   if (a->value + a->section->vma > b->value + b->section->vma)
3043     return 1;
3044
3045   /* For syms with the same value, prefer strong dynamic global function
3046      syms over other syms.  */
3047   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3048     return -1;
3049
3050   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3051     return 1;
3052
3053   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3054     return -1;
3055
3056   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3057     return 1;
3058
3059   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3060     return -1;
3061
3062   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3063     return 1;
3064
3065   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3066     return -1;
3067
3068   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3069     return 1;
3070
3071   return 0;
3072 }
3073
3074 /* Search SYMS for a symbol of the given VALUE.  */
3075
3076 static asymbol *
3077 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3078 {
3079   long mid;
3080
3081   if (id == -1)
3082     {
3083       while (lo < hi)
3084         {
3085           mid = (lo + hi) >> 1;
3086           if (syms[mid]->value + syms[mid]->section->vma < value)
3087             lo = mid + 1;
3088           else if (syms[mid]->value + syms[mid]->section->vma > value)
3089             hi = mid;
3090           else
3091             return syms[mid];
3092         }
3093     }
3094   else
3095     {
3096       while (lo < hi)
3097         {
3098           mid = (lo + hi) >> 1;
3099           if (syms[mid]->section->id < id)
3100             lo = mid + 1;
3101           else if (syms[mid]->section->id > id)
3102             hi = mid;
3103           else if (syms[mid]->value < value)
3104             lo = mid + 1;
3105           else if (syms[mid]->value > value)
3106             hi = mid;
3107           else
3108             return syms[mid];
3109         }
3110     }
3111   return NULL;
3112 }
3113
3114 static bfd_boolean
3115 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3116 {
3117   bfd_vma vma = *(bfd_vma *) ptr;
3118   return ((section->flags & SEC_ALLOC) != 0
3119           && section->vma <= vma
3120           && vma < section->vma + section->size);
3121 }
3122
3123 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3124    entry syms.  Also generate @plt symbols for the glink branch table.  */
3125
3126 static long
3127 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3128                                 long static_count, asymbol **static_syms,
3129                                 long dyn_count, asymbol **dyn_syms,
3130                                 asymbol **ret)
3131 {
3132   asymbol *s;
3133   long i;
3134   long count;
3135   char *names;
3136   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3137   asection *opd = NULL;
3138   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3139   asymbol **syms;
3140   int abi = abiversion (abfd);
3141
3142   *ret = NULL;
3143
3144   if (abi < 2)
3145     {
3146       opd = bfd_get_section_by_name (abfd, ".opd");
3147       if (opd == NULL && abi == 1)
3148         return 0;
3149     }
3150
3151   symcount = static_count;
3152   if (!relocatable)
3153     symcount += dyn_count;
3154   if (symcount == 0)
3155     return 0;
3156
3157   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3158   if (syms == NULL)
3159     return -1;
3160
3161   if (!relocatable && static_count != 0 && dyn_count != 0)
3162     {
3163       /* Use both symbol tables.  */
3164       memcpy (syms, static_syms, static_count * sizeof (*syms));
3165       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3166     }
3167   else if (!relocatable && static_count == 0)
3168     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3169   else
3170     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3171
3172   synthetic_relocatable = relocatable;
3173   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3174
3175   if (!relocatable && symcount > 1)
3176     {
3177       long j;
3178       /* Trim duplicate syms, since we may have merged the normal and
3179          dynamic symbols.  Actually, we only care about syms that have
3180          different values, so trim any with the same value.  */
3181       for (i = 1, j = 1; i < symcount; ++i)
3182         if (syms[i - 1]->value + syms[i - 1]->section->vma
3183             != syms[i]->value + syms[i]->section->vma)
3184           syms[j++] = syms[i];
3185       symcount = j;
3186     }
3187
3188   i = 0;
3189   if (strcmp (syms[i]->section->name, ".opd") == 0)
3190     ++i;
3191   codesecsym = i;
3192
3193   for (; i < symcount; ++i)
3194     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195          != (SEC_CODE | SEC_ALLOC))
3196         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3197       break;
3198   codesecsymend = i;
3199
3200   for (; i < symcount; ++i)
3201     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3202       break;
3203   secsymend = i;
3204
3205   for (; i < symcount; ++i)
3206     if (strcmp (syms[i]->section->name, ".opd") != 0)
3207       break;
3208   opdsymend = i;
3209
3210   for (; i < symcount; ++i)
3211     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3212         != (SEC_CODE | SEC_ALLOC))
3213       break;
3214   symcount = i;
3215
3216   count = 0;
3217
3218   if (relocatable)
3219     {
3220       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3221       arelent *r;
3222       size_t size;
3223       long relcount;
3224
3225       if (opdsymend == secsymend)
3226         goto done;
3227
3228       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3229       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3230       if (relcount == 0)
3231         goto done;
3232
3233       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3234         {
3235           count = -1;
3236           goto done;
3237         }
3238
3239       size = 0;
3240       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3241         {
3242           asymbol *sym;
3243
3244           while (r < opd->relocation + relcount
3245                  && r->address < syms[i]->value + opd->vma)
3246             ++r;
3247
3248           if (r == opd->relocation + relcount)
3249             break;
3250
3251           if (r->address != syms[i]->value + opd->vma)
3252             continue;
3253
3254           if (r->howto->type != R_PPC64_ADDR64)
3255             continue;
3256
3257           sym = *r->sym_ptr_ptr;
3258           if (!sym_exists_at (syms, opdsymend, symcount,
3259                               sym->section->id, sym->value + r->addend))
3260             {
3261               ++count;
3262               size += sizeof (asymbol);
3263               size += strlen (syms[i]->name) + 2;
3264             }
3265         }
3266
3267       s = *ret = bfd_malloc (size);
3268       if (s == NULL)
3269         {
3270           count = -1;
3271           goto done;
3272         }
3273
3274       names = (char *) (s + count);
3275
3276       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3277         {
3278           asymbol *sym;
3279
3280           while (r < opd->relocation + relcount
3281                  && r->address < syms[i]->value + opd->vma)
3282             ++r;
3283
3284           if (r == opd->relocation + relcount)
3285             break;
3286
3287           if (r->address != syms[i]->value + opd->vma)
3288             continue;
3289
3290           if (r->howto->type != R_PPC64_ADDR64)
3291             continue;
3292
3293           sym = *r->sym_ptr_ptr;
3294           if (!sym_exists_at (syms, opdsymend, symcount,
3295                               sym->section->id, sym->value + r->addend))
3296             {
3297               size_t len;
3298
3299               *s = *syms[i];
3300               s->flags |= BSF_SYNTHETIC;
3301               s->section = sym->section;
3302               s->value = sym->value + r->addend;
3303               s->name = names;
3304               *names++ = '.';
3305               len = strlen (syms[i]->name);
3306               memcpy (names, syms[i]->name, len + 1);
3307               names += len + 1;
3308               /* Have udata.p point back to the original symbol this
3309                  synthetic symbol was derived from.  */
3310               s->udata.p = syms[i];
3311               s++;
3312             }
3313         }
3314     }
3315   else
3316     {
3317       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3318       bfd_byte *contents = NULL;
3319       size_t size;
3320       long plt_count = 0;
3321       bfd_vma glink_vma = 0, resolv_vma = 0;
3322       asection *dynamic, *glink = NULL, *relplt = NULL;
3323       arelent *p;
3324
3325       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3326         {
3327         free_contents_and_exit:
3328           if (contents)
3329             free (contents);
3330           count = -1;
3331           goto done;
3332         }
3333
3334       size = 0;
3335       for (i = secsymend; i < opdsymend; ++i)
3336         {
3337           bfd_vma ent;
3338
3339           /* Ignore bogus symbols.  */
3340           if (syms[i]->value > opd->size - 8)
3341             continue;
3342
3343           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3344           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3345             {
3346               ++count;
3347               size += sizeof (asymbol);
3348               size += strlen (syms[i]->name) + 2;
3349             }
3350         }
3351
3352       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3353       if (dyn_count != 0
3354           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3355         {
3356           bfd_byte *dynbuf, *extdyn, *extdynend;
3357           size_t extdynsize;
3358           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3359
3360           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3361             goto free_contents_and_exit;
3362
3363           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3364           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3365
3366           extdyn = dynbuf;
3367           extdynend = extdyn + dynamic->size;
3368           for (; extdyn < extdynend; extdyn += extdynsize)
3369             {
3370               Elf_Internal_Dyn dyn;
3371               (*swap_dyn_in) (abfd, extdyn, &dyn);
3372
3373               if (dyn.d_tag == DT_NULL)
3374                 break;
3375
3376               if (dyn.d_tag == DT_PPC64_GLINK)
3377                 {
3378                   /* The first glink stub starts at offset 32; see
3379                      comment in ppc64_elf_finish_dynamic_sections. */
3380                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3381                   /* The .glink section usually does not survive the final
3382                      link; search for the section (usually .text) where the
3383                      glink stubs now reside.  */
3384                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3385                                                 &glink_vma);
3386                   break;
3387                 }
3388             }
3389
3390           free (dynbuf);
3391         }
3392
3393       if (glink != NULL)
3394         {
3395           /* Determine __glink trampoline by reading the relative branch
3396              from the first glink stub.  */
3397           bfd_byte buf[4];
3398           unsigned int off = 0;
3399
3400           while (bfd_get_section_contents (abfd, glink, buf,
3401                                            glink_vma + off - glink->vma, 4))
3402             {
3403               unsigned int insn = bfd_get_32 (abfd, buf);
3404               insn ^= B_DOT;
3405               if ((insn & ~0x3fffffc) == 0)
3406                 {
3407                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3408                   break;
3409                 }
3410               off += 4;
3411               if (off > 4)
3412                 break;
3413             }
3414
3415           if (resolv_vma)
3416             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3417
3418           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3419           if (relplt != NULL)
3420             {
3421               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3422               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3423                 goto free_contents_and_exit;
3424
3425               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3426               size += plt_count * sizeof (asymbol);
3427
3428               p = relplt->relocation;
3429               for (i = 0; i < plt_count; i++, p++)
3430                 {
3431                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3432                   if (p->addend != 0)
3433                     size += sizeof ("+0x") - 1 + 16;
3434                 }
3435             }
3436         }
3437
3438       s = *ret = bfd_malloc (size);
3439       if (s == NULL)
3440         goto free_contents_and_exit;
3441
3442       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3443
3444       for (i = secsymend; i < opdsymend; ++i)
3445         {
3446           bfd_vma ent;
3447
3448           if (syms[i]->value > opd->size - 8)
3449             continue;
3450
3451           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453             {
3454               long lo, hi;
3455               size_t len;
3456               asection *sec = abfd->sections;
3457
3458               *s = *syms[i];
3459               lo = codesecsym;
3460               hi = codesecsymend;
3461               while (lo < hi)
3462                 {
3463                   long mid = (lo + hi) >> 1;
3464                   if (syms[mid]->section->vma < ent)
3465                     lo = mid + 1;
3466                   else if (syms[mid]->section->vma > ent)
3467                     hi = mid;
3468                   else
3469                     {
3470                       sec = syms[mid]->section;
3471                       break;
3472                     }
3473                 }
3474
3475               if (lo >= hi && lo > codesecsym)
3476                 sec = syms[lo - 1]->section;
3477
3478               for (; sec != NULL; sec = sec->next)
3479                 {
3480                   if (sec->vma > ent)
3481                     break;
3482                   /* SEC_LOAD may not be set if SEC is from a separate debug
3483                      info file.  */
3484                   if ((sec->flags & SEC_ALLOC) == 0)
3485                     break;
3486                   if ((sec->flags & SEC_CODE) != 0)
3487                     s->section = sec;
3488                 }
3489               s->flags |= BSF_SYNTHETIC;
3490               s->value = ent - s->section->vma;
3491               s->name = names;
3492               *names++ = '.';
3493               len = strlen (syms[i]->name);
3494               memcpy (names, syms[i]->name, len + 1);
3495               names += len + 1;
3496               /* Have udata.p point back to the original symbol this
3497                  synthetic symbol was derived from.  */
3498               s->udata.p = syms[i];
3499               s++;
3500             }
3501         }
3502       free (contents);
3503
3504       if (glink != NULL && relplt != NULL)
3505         {
3506           if (resolv_vma)
3507             {
3508               /* Add a symbol for the main glink trampoline.  */
3509               memset (s, 0, sizeof *s);
3510               s->the_bfd = abfd;
3511               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3512               s->section = glink;
3513               s->value = resolv_vma - glink->vma;
3514               s->name = names;
3515               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3516               names += sizeof ("__glink_PLTresolve");
3517               s++;
3518               count++;
3519             }
3520
3521           /* FIXME: It would be very much nicer to put sym@plt on the
3522              stub rather than on the glink branch table entry.  The
3523              objdump disassembler would then use a sensible symbol
3524              name on plt calls.  The difficulty in doing so is
3525              a) finding the stubs, and,
3526              b) matching stubs against plt entries, and,
3527              c) there can be multiple stubs for a given plt entry.
3528
3529              Solving (a) could be done by code scanning, but older
3530              ppc64 binaries used different stubs to current code.
3531              (b) is the tricky one since you need to known the toc
3532              pointer for at least one function that uses a pic stub to
3533              be able to calculate the plt address referenced.
3534              (c) means gdb would need to set multiple breakpoints (or
3535              find the glink branch itself) when setting breakpoints
3536              for pending shared library loads.  */
3537           p = relplt->relocation;
3538           for (i = 0; i < plt_count; i++, p++)
3539             {
3540               size_t len;
3541
3542               *s = **p->sym_ptr_ptr;
3543               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3544                  we are defining a symbol, ensure one of them is set.  */
3545               if ((s->flags & BSF_LOCAL) == 0)
3546                 s->flags |= BSF_GLOBAL;
3547               s->flags |= BSF_SYNTHETIC;
3548               s->section = glink;
3549               s->value = glink_vma - glink->vma;
3550               s->name = names;
3551               s->udata.p = NULL;
3552               len = strlen ((*p->sym_ptr_ptr)->name);
3553               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3554               names += len;
3555               if (p->addend != 0)
3556                 {
3557                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3558                   names += sizeof ("+0x") - 1;
3559                   bfd_sprintf_vma (abfd, names, p->addend);
3560                   names += strlen (names);
3561                 }
3562               memcpy (names, "@plt", sizeof ("@plt"));
3563               names += sizeof ("@plt");
3564               s++;
3565               if (abi < 2)
3566                 {
3567                   glink_vma += 8;
3568                   if (i >= 0x8000)
3569                     glink_vma += 4;
3570                 }
3571               else
3572                 glink_vma += 4;
3573             }
3574           count += plt_count;
3575         }
3576     }
3577
3578  done:
3579   free (syms);
3580   return count;
3581 }
3582 \f
3583 /* The following functions are specific to the ELF linker, while
3584    functions above are used generally.  Those named ppc64_elf_* are
3585    called by the main ELF linker code.  They appear in this file more
3586    or less in the order in which they are called.  eg.
3587    ppc64_elf_check_relocs is called early in the link process,
3588    ppc64_elf_finish_dynamic_sections is one of the last functions
3589    called.
3590
3591    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3592    functions have both a function code symbol and a function descriptor
3593    symbol.  A call to foo in a relocatable object file looks like:
3594
3595    .            .text
3596    .    x:
3597    .            bl      .foo
3598    .            nop
3599
3600    The function definition in another object file might be:
3601
3602    .            .section .opd
3603    .    foo:    .quad   .foo
3604    .            .quad   .TOC.@tocbase
3605    .            .quad   0
3606    .
3607    .            .text
3608    .    .foo:   blr
3609
3610    When the linker resolves the call during a static link, the branch
3611    unsurprisingly just goes to .foo and the .opd information is unused.
3612    If the function definition is in a shared library, things are a little
3613    different:  The call goes via a plt call stub, the opd information gets
3614    copied to the plt, and the linker patches the nop.
3615
3616    .    x:
3617    .            bl      .foo_stub
3618    .            ld      2,40(1)
3619    .
3620    .
3621    .    .foo_stub:
3622    .            std     2,40(1)                 # in practice, the call stub
3623    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3624    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3625    .            ld      12,0(11)
3626    .            ld      2,8(11)
3627    .            mtctr   12
3628    .            ld      11,16(11)
3629    .            bctr
3630    .
3631    .            .section .plt
3632    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3633
3634    The "reloc ()" notation is supposed to indicate that the linker emits
3635    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3636    copying.
3637
3638    What are the difficulties here?  Well, firstly, the relocations
3639    examined by the linker in check_relocs are against the function code
3640    sym .foo, while the dynamic relocation in the plt is emitted against
3641    the function descriptor symbol, foo.  Somewhere along the line, we need
3642    to carefully copy dynamic link information from one symbol to the other.
3643    Secondly, the generic part of the elf linker will make .foo a dynamic
3644    symbol as is normal for most other backends.  We need foo dynamic
3645    instead, at least for an application final link.  However, when
3646    creating a shared library containing foo, we need to have both symbols
3647    dynamic so that references to .foo are satisfied during the early
3648    stages of linking.  Otherwise the linker might decide to pull in a
3649    definition from some other object, eg. a static library.
3650
3651    Update: As of August 2004, we support a new convention.  Function
3652    calls may use the function descriptor symbol, ie. "bl foo".  This
3653    behaves exactly as "bl .foo".  */
3654
3655 /* Of those relocs that might be copied as dynamic relocs, this function
3656    selects those that must be copied when linking a shared library,
3657    even when the symbol is local.  */
3658
3659 static int
3660 must_be_dyn_reloc (struct bfd_link_info *info,
3661                    enum elf_ppc64_reloc_type r_type)
3662 {
3663   switch (r_type)
3664     {
3665     default:
3666       return 1;
3667
3668     case R_PPC64_REL32:
3669     case R_PPC64_REL64:
3670     case R_PPC64_REL30:
3671       return 0;
3672
3673     case R_PPC64_TPREL16:
3674     case R_PPC64_TPREL16_LO:
3675     case R_PPC64_TPREL16_HI:
3676     case R_PPC64_TPREL16_HA:
3677     case R_PPC64_TPREL16_DS:
3678     case R_PPC64_TPREL16_LO_DS:
3679     case R_PPC64_TPREL16_HIGH:
3680     case R_PPC64_TPREL16_HIGHA:
3681     case R_PPC64_TPREL16_HIGHER:
3682     case R_PPC64_TPREL16_HIGHERA:
3683     case R_PPC64_TPREL16_HIGHEST:
3684     case R_PPC64_TPREL16_HIGHESTA:
3685     case R_PPC64_TPREL64:
3686       return !info->executable;
3687     }
3688 }
3689
3690 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3691    copying dynamic variables from a shared lib into an app's dynbss
3692    section, and instead use a dynamic relocation to point into the
3693    shared lib.  With code that gcc generates, it's vital that this be
3694    enabled;  In the PowerPC64 ABI, the address of a function is actually
3695    the address of a function descriptor, which resides in the .opd
3696    section.  gcc uses the descriptor directly rather than going via the
3697    GOT as some other ABI's do, which means that initialized function
3698    pointers must reference the descriptor.  Thus, a function pointer
3699    initialized to the address of a function in a shared library will
3700    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3701    redefines the function descriptor symbol to point to the copy.  This
3702    presents a problem as a plt entry for that function is also
3703    initialized from the function descriptor symbol and the copy reloc
3704    may not be initialized first.  */
3705 #define ELIMINATE_COPY_RELOCS 1
3706
3707 /* Section name for stubs is the associated section name plus this
3708    string.  */
3709 #define STUB_SUFFIX ".stub"
3710
3711 /* Linker stubs.
3712    ppc_stub_long_branch:
3713    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3714    destination, but a 24 bit branch in a stub section will reach.
3715    .    b       dest
3716
3717    ppc_stub_plt_branch:
3718    Similar to the above, but a 24 bit branch in the stub section won't
3719    reach its destination.
3720    .    addis   %r11,%r2,xxx@toc@ha
3721    .    ld      %r12,xxx@toc@l(%r11)
3722    .    mtctr   %r12
3723    .    bctr
3724
3725    ppc_stub_plt_call:
3726    Used to call a function in a shared library.  If it so happens that
3727    the plt entry referenced crosses a 64k boundary, then an extra
3728    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3729    .    std     %r2,40(%r1)
3730    .    addis   %r11,%r2,xxx@toc@ha
3731    .    ld      %r12,xxx+0@toc@l(%r11)
3732    .    mtctr   %r12
3733    .    ld      %r2,xxx+8@toc@l(%r11)
3734    .    ld      %r11,xxx+16@toc@l(%r11)
3735    .    bctr
3736
3737    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3738    code to adjust the value and save r2 to support multiple toc sections.
3739    A ppc_stub_long_branch with an r2 offset looks like:
3740    .    std     %r2,40(%r1)
3741    .    addis   %r2,%r2,off@ha
3742    .    addi    %r2,%r2,off@l
3743    .    b       dest
3744
3745    A ppc_stub_plt_branch with an r2 offset looks like:
3746    .    std     %r2,40(%r1)
3747    .    addis   %r11,%r2,xxx@toc@ha
3748    .    ld      %r12,xxx@toc@l(%r11)
3749    .    addis   %r2,%r2,off@ha
3750    .    addi    %r2,%r2,off@l
3751    .    mtctr   %r12
3752    .    bctr
3753
3754    In cases where the "addis" instruction would add zero, the "addis" is
3755    omitted and following instructions modified slightly in some cases.
3756 */
3757
3758 enum ppc_stub_type {
3759   ppc_stub_none,
3760   ppc_stub_long_branch,
3761   ppc_stub_long_branch_r2off,
3762   ppc_stub_plt_branch,
3763   ppc_stub_plt_branch_r2off,
3764   ppc_stub_plt_call,
3765   ppc_stub_plt_call_r2save
3766 };
3767
3768 struct ppc_stub_hash_entry {
3769
3770   /* Base hash table entry structure.  */
3771   struct bfd_hash_entry root;
3772
3773   enum ppc_stub_type stub_type;
3774
3775   /* The stub section.  */
3776   asection *stub_sec;
3777
3778   /* Offset within stub_sec of the beginning of this stub.  */
3779   bfd_vma stub_offset;
3780
3781   /* Given the symbol's value and its section we can determine its final
3782      value when building the stubs (so the stub knows where to jump.  */
3783   bfd_vma target_value;
3784   asection *target_section;
3785
3786   /* The symbol table entry, if any, that this was derived from.  */
3787   struct ppc_link_hash_entry *h;
3788   struct plt_entry *plt_ent;
3789
3790   /* Where this stub is being called from, or, in the case of combined
3791      stub sections, the first input section in the group.  */
3792   asection *id_sec;
3793
3794   /* Symbol st_other.  */
3795   unsigned char other;
3796 };
3797
3798 struct ppc_branch_hash_entry {
3799
3800   /* Base hash table entry structure.  */
3801   struct bfd_hash_entry root;
3802
3803   /* Offset within branch lookup table.  */
3804   unsigned int offset;
3805
3806   /* Generation marker.  */
3807   unsigned int iter;
3808 };
3809
3810 /* Used to track dynamic relocations for local symbols.  */
3811 struct ppc_dyn_relocs
3812 {
3813   struct ppc_dyn_relocs *next;
3814
3815   /* The input section of the reloc.  */
3816   asection *sec;
3817
3818   /* Total number of relocs copied for the input section.  */
3819   unsigned int count : 31;
3820
3821   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3822   unsigned int ifunc : 1;
3823 };
3824
3825 struct ppc_link_hash_entry
3826 {
3827   struct elf_link_hash_entry elf;
3828
3829   union {
3830     /* A pointer to the most recently used stub hash entry against this
3831        symbol.  */
3832     struct ppc_stub_hash_entry *stub_cache;
3833
3834     /* A pointer to the next symbol starting with a '.'  */
3835     struct ppc_link_hash_entry *next_dot_sym;
3836   } u;
3837
3838   /* Track dynamic relocs copied for this symbol.  */
3839   struct elf_dyn_relocs *dyn_relocs;
3840
3841   /* Link between function code and descriptor symbols.  */
3842   struct ppc_link_hash_entry *oh;
3843
3844   /* Flag function code and descriptor symbols.  */
3845   unsigned int is_func:1;
3846   unsigned int is_func_descriptor:1;
3847   unsigned int fake:1;
3848
3849   /* Whether global opd/toc sym has been adjusted or not.
3850      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3851      should be set for all globals defined in any opd/toc section.  */
3852   unsigned int adjust_done:1;
3853
3854   /* Set if we twiddled this symbol to weak at some stage.  */
3855   unsigned int was_undefined:1;
3856
3857   /* Contexts in which symbol is used in the GOT (or TOC).
3858      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3859      corresponding relocs are encountered during check_relocs.
3860      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3861      indicate the corresponding GOT entry type is not needed.
3862      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3863      a TPREL one.  We use a separate flag rather than setting TPREL
3864      just for convenience in distinguishing the two cases.  */
3865 #define TLS_GD           1      /* GD reloc. */
3866 #define TLS_LD           2      /* LD reloc. */
3867 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3868 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3869 #define TLS_TLS         16      /* Any TLS reloc.  */
3870 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3871 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3872 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3873   unsigned char tls_mask;
3874 };
3875
3876 /* ppc64 ELF linker hash table.  */
3877
3878 struct ppc_link_hash_table
3879 {
3880   struct elf_link_hash_table elf;
3881
3882   /* The stub hash table.  */
3883   struct bfd_hash_table stub_hash_table;
3884
3885   /* Another hash table for plt_branch stubs.  */
3886   struct bfd_hash_table branch_hash_table;
3887
3888   /* Hash table for function prologue tocsave.  */
3889   htab_t tocsave_htab;
3890
3891   /* Various options and other info passed from the linker.  */
3892   struct ppc64_elf_params *params;
3893
3894   /* Array to keep track of which stub sections have been created, and
3895      information on stub grouping.  */
3896   struct map_stub {
3897     /* This is the section to which stubs in the group will be attached.  */
3898     asection *link_sec;
3899     /* The stub section.  */
3900     asection *stub_sec;
3901     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3902     bfd_vma toc_off;
3903   } *stub_group;
3904
3905   /* Temp used when calculating TOC pointers.  */
3906   bfd_vma toc_curr;
3907   bfd *toc_bfd;
3908   asection *toc_first_sec;
3909
3910   /* Highest input section id.  */
3911   int top_id;
3912
3913   /* Highest output section index.  */
3914   int top_index;
3915
3916   /* Used when adding symbols.  */
3917   struct ppc_link_hash_entry *dot_syms;
3918
3919   /* List of input sections for each output section.  */
3920   asection **input_list;
3921
3922   /* Shortcuts to get to dynamic linker sections.  */
3923   asection *dynbss;
3924   asection *relbss;
3925   asection *glink;
3926   asection *sfpr;
3927   asection *brlt;
3928   asection *relbrlt;
3929   asection *glink_eh_frame;
3930
3931   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3932   struct ppc_link_hash_entry *tls_get_addr;
3933   struct ppc_link_hash_entry *tls_get_addr_fd;
3934
3935   /* The size of reliplt used by got entry relocs.  */
3936   bfd_size_type got_reli_size;
3937
3938   /* Statistics.  */
3939   unsigned long stub_count[ppc_stub_plt_call_r2save];
3940
3941   /* Number of stubs against global syms.  */
3942   unsigned long stub_globals;
3943
3944   /* Set if we're linking code with function descriptors.  */
3945   unsigned int opd_abi:1;
3946
3947   /* Support for multiple toc sections.  */
3948   unsigned int do_multi_toc:1;
3949   unsigned int multi_toc_needed:1;
3950   unsigned int second_toc_pass:1;
3951   unsigned int do_toc_opt:1;
3952
3953   /* Set on error.  */
3954   unsigned int stub_error:1;
3955
3956   /* Temp used by ppc64_elf_before_check_relocs.  */
3957   unsigned int twiddled_syms:1;
3958
3959   /* Incremented every time we size stubs.  */
3960   unsigned int stub_iteration;
3961
3962   /* Small local sym cache.  */
3963   struct sym_cache sym_cache;
3964 };
3965
3966 /* Rename some of the generic section flags to better document how they
3967    are used here.  */
3968
3969 /* Nonzero if this section has TLS related relocations.  */
3970 #define has_tls_reloc sec_flg0
3971
3972 /* Nonzero if this section has a call to __tls_get_addr.  */
3973 #define has_tls_get_addr_call sec_flg1
3974
3975 /* Nonzero if this section has any toc or got relocs.  */
3976 #define has_toc_reloc sec_flg2
3977
3978 /* Nonzero if this section has a call to another section that uses
3979    the toc or got.  */
3980 #define makes_toc_func_call sec_flg3
3981
3982 /* Recursion protection when determining above flag.  */
3983 #define call_check_in_progress sec_flg4
3984 #define call_check_done sec_flg5
3985
3986 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3987
3988 #define ppc_hash_table(p) \
3989   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3990   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3991
3992 #define ppc_stub_hash_lookup(table, string, create, copy) \
3993   ((struct ppc_stub_hash_entry *) \
3994    bfd_hash_lookup ((table), (string), (create), (copy)))
3995
3996 #define ppc_branch_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_branch_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 /* Create an entry in the stub hash table.  */
4001
4002 static struct bfd_hash_entry *
4003 stub_hash_newfunc (struct bfd_hash_entry *entry,
4004                    struct bfd_hash_table *table,
4005                    const char *string)
4006 {
4007   /* Allocate the structure if it has not already been allocated by a
4008      subclass.  */
4009   if (entry == NULL)
4010     {
4011       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4012       if (entry == NULL)
4013         return entry;
4014     }
4015
4016   /* Call the allocation method of the superclass.  */
4017   entry = bfd_hash_newfunc (entry, table, string);
4018   if (entry != NULL)
4019     {
4020       struct ppc_stub_hash_entry *eh;
4021
4022       /* Initialize the local fields.  */
4023       eh = (struct ppc_stub_hash_entry *) entry;
4024       eh->stub_type = ppc_stub_none;
4025       eh->stub_sec = NULL;
4026       eh->stub_offset = 0;
4027       eh->target_value = 0;
4028       eh->target_section = NULL;
4029       eh->h = NULL;
4030       eh->plt_ent = NULL;
4031       eh->id_sec = NULL;
4032       eh->other = 0;
4033     }
4034
4035   return entry;
4036 }
4037
4038 /* Create an entry in the branch hash table.  */
4039
4040 static struct bfd_hash_entry *
4041 branch_hash_newfunc (struct bfd_hash_entry *entry,
4042                      struct bfd_hash_table *table,
4043                      const char *string)
4044 {
4045   /* Allocate the structure if it has not already been allocated by a
4046      subclass.  */
4047   if (entry == NULL)
4048     {
4049       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4050       if (entry == NULL)
4051         return entry;
4052     }
4053
4054   /* Call the allocation method of the superclass.  */
4055   entry = bfd_hash_newfunc (entry, table, string);
4056   if (entry != NULL)
4057     {
4058       struct ppc_branch_hash_entry *eh;
4059
4060       /* Initialize the local fields.  */
4061       eh = (struct ppc_branch_hash_entry *) entry;
4062       eh->offset = 0;
4063       eh->iter = 0;
4064     }
4065
4066   return entry;
4067 }
4068
4069 /* Create an entry in a ppc64 ELF linker hash table.  */
4070
4071 static struct bfd_hash_entry *
4072 link_hash_newfunc (struct bfd_hash_entry *entry,
4073                    struct bfd_hash_table *table,
4074                    const char *string)
4075 {
4076   /* Allocate the structure if it has not already been allocated by a
4077      subclass.  */
4078   if (entry == NULL)
4079     {
4080       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4081       if (entry == NULL)
4082         return entry;
4083     }
4084
4085   /* Call the allocation method of the superclass.  */
4086   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4087   if (entry != NULL)
4088     {
4089       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4090
4091       memset (&eh->u.stub_cache, 0,
4092               (sizeof (struct ppc_link_hash_entry)
4093                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4094
4095       /* When making function calls, old ABI code references function entry
4096          points (dot symbols), while new ABI code references the function
4097          descriptor symbol.  We need to make any combination of reference and
4098          definition work together, without breaking archive linking.
4099
4100          For a defined function "foo" and an undefined call to "bar":
4101          An old object defines "foo" and ".foo", references ".bar" (possibly
4102          "bar" too).
4103          A new object defines "foo" and references "bar".
4104
4105          A new object thus has no problem with its undefined symbols being
4106          satisfied by definitions in an old object.  On the other hand, the
4107          old object won't have ".bar" satisfied by a new object.
4108
4109          Keep a list of newly added dot-symbols.  */
4110
4111       if (string[0] == '.')
4112         {
4113           struct ppc_link_hash_table *htab;
4114
4115           htab = (struct ppc_link_hash_table *) table;
4116           eh->u.next_dot_sym = htab->dot_syms;
4117           htab->dot_syms = eh;
4118         }
4119     }
4120
4121   return entry;
4122 }
4123
4124 struct tocsave_entry {
4125   asection *sec;
4126   bfd_vma offset;
4127 };
4128
4129 static hashval_t
4130 tocsave_htab_hash (const void *p)
4131 {
4132   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4133   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4134 }
4135
4136 static int
4137 tocsave_htab_eq (const void *p1, const void *p2)
4138 {
4139   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4140   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4141   return e1->sec == e2->sec && e1->offset == e2->offset;
4142 }
4143
4144 /* 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 /* Set up opd section info and abiversion for IBFD, and process list
4934    of dot-symbols we made in link_hash_newfunc.  */
4935
4936 static bfd_boolean
4937 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4938 {
4939   struct ppc_link_hash_table *htab;
4940   struct ppc_link_hash_entry **p, *eh;
4941
4942   if (!is_ppc64_elf (info->output_bfd))
4943     return TRUE;
4944   htab = ppc_hash_table (info);
4945   if (htab == NULL)
4946     return FALSE;
4947
4948   if (is_ppc64_elf (ibfd))
4949     {
4950       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4951
4952       if (opd != NULL && opd->size != 0)
4953         {
4954           if (abiversion (ibfd) == 0)
4955             set_abiversion (ibfd, 1);
4956           else if (abiversion (ibfd) == 2)
4957             {
4958               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4959                                         " version %d\n"),
4960                                       ibfd, abiversion (ibfd));
4961               bfd_set_error (bfd_error_bad_value);
4962               return FALSE;
4963             }
4964
4965           if ((ibfd->flags & DYNAMIC) == 0
4966               && (opd->flags & SEC_RELOC) != 0
4967               && opd->reloc_count != 0
4968               && !bfd_is_abs_section (opd->output_section))
4969             {
4970               /* Garbage collection needs some extra help with .opd sections.
4971                  We don't want to necessarily keep everything referenced by
4972                  relocs in .opd, as that would keep all functions.  Instead,
4973                  if we reference an .opd symbol (a function descriptor), we
4974                  want to keep the function code symbol's section.  This is
4975                  easy for global symbols, but for local syms we need to keep
4976                  information about the associated function section.  */
4977               bfd_size_type amt;
4978               asection **opd_sym_map;
4979
4980               amt = opd->size * sizeof (*opd_sym_map) / 8;
4981               opd_sym_map = bfd_zalloc (ibfd, amt);
4982               if (opd_sym_map == NULL)
4983                 return FALSE;
4984               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4985               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4986               ppc64_elf_section_data (opd)->sec_type = sec_opd;
4987             }
4988         }
4989
4990       /* For input files without an explicit abiversion in e_flags
4991          we should have flagged any with symbol st_other bits set
4992          as ELFv1 and above flagged those with .opd as ELFv2.
4993          Set the output abiversion if not yet set, and for any input
4994          still ambiguous, take its abiversion from the output.
4995          Differences in ABI are reported later.  */
4996       if (abiversion (info->output_bfd) == 0)
4997         set_abiversion (info->output_bfd, abiversion (ibfd));
4998       else if (abiversion (ibfd) == 0)
4999         set_abiversion (ibfd, abiversion (info->output_bfd));
5000
5001       p = &htab->dot_syms;
5002       while ((eh = *p) != NULL)
5003         {
5004           *p = NULL;
5005           if (&eh->elf == htab->elf.hgot)
5006             ;
5007           else if (htab->elf.hgot == NULL
5008                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5009             htab->elf.hgot = &eh->elf;
5010           else if (!add_symbol_adjust (eh, info))
5011             return FALSE;
5012           p = &eh->u.next_dot_sym;
5013         }
5014     }
5015
5016   /* Clear the list for non-ppc64 input files.  */
5017   p = &htab->dot_syms;
5018   while ((eh = *p) != NULL)
5019     {
5020       *p = NULL;
5021       p = &eh->u.next_dot_sym;
5022     }
5023
5024   /* We need to fix the undefs list for any syms we have twiddled to
5025      undef_weak.  */
5026   if (htab->twiddled_syms)
5027     {
5028       bfd_link_repair_undef_list (&htab->elf.root);
5029       htab->twiddled_syms = 0;
5030     }
5031   return TRUE;
5032 }
5033
5034 /* Undo hash table changes when an --as-needed input file is determined
5035    not to be needed.  */
5036
5037 static bfd_boolean
5038 ppc64_elf_notice_as_needed (bfd *ibfd,
5039                             struct bfd_link_info *info,
5040                             enum notice_asneeded_action act)
5041 {
5042   if (act == notice_not_needed)
5043     {
5044       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5045
5046       if (htab == NULL)
5047         return FALSE;
5048
5049       htab->dot_syms = NULL;
5050     }
5051   return _bfd_elf_notice_as_needed (ibfd, info, act);
5052 }
5053
5054 /* If --just-symbols against a final linked binary, then assume we need
5055    toc adjusting stubs when calling functions defined there.  */
5056
5057 static void
5058 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5059 {
5060   if ((sec->flags & SEC_CODE) != 0
5061       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5062       && is_ppc64_elf (sec->owner))
5063     {
5064       if (abiversion (sec->owner) >= 2
5065           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5066         sec->has_toc_reloc = 1;
5067     }
5068   _bfd_elf_link_just_syms (sec, info);
5069 }
5070
5071 static struct plt_entry **
5072 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5073                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5074 {
5075   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5076   struct plt_entry **local_plt;
5077   unsigned char *local_got_tls_masks;
5078
5079   if (local_got_ents == NULL)
5080     {
5081       bfd_size_type size = symtab_hdr->sh_info;
5082
5083       size *= (sizeof (*local_got_ents)
5084                + sizeof (*local_plt)
5085                + sizeof (*local_got_tls_masks));
5086       local_got_ents = bfd_zalloc (abfd, size);
5087       if (local_got_ents == NULL)
5088         return NULL;
5089       elf_local_got_ents (abfd) = local_got_ents;
5090     }
5091
5092   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5093     {
5094       struct got_entry *ent;
5095
5096       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5097         if (ent->addend == r_addend
5098             && ent->owner == abfd
5099             && ent->tls_type == tls_type)
5100           break;
5101       if (ent == NULL)
5102         {
5103           bfd_size_type amt = sizeof (*ent);
5104           ent = bfd_alloc (abfd, amt);
5105           if (ent == NULL)
5106             return FALSE;
5107           ent->next = local_got_ents[r_symndx];
5108           ent->addend = r_addend;
5109           ent->owner = abfd;
5110           ent->tls_type = tls_type;
5111           ent->is_indirect = FALSE;
5112           ent->got.refcount = 0;
5113           local_got_ents[r_symndx] = ent;
5114         }
5115       ent->got.refcount += 1;
5116     }
5117
5118   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5119   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5120   local_got_tls_masks[r_symndx] |= tls_type;
5121
5122   return local_plt + r_symndx;
5123 }
5124
5125 static bfd_boolean
5126 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5127 {
5128   struct plt_entry *ent;
5129
5130   for (ent = *plist; ent != NULL; ent = ent->next)
5131     if (ent->addend == addend)
5132       break;
5133   if (ent == NULL)
5134     {
5135       bfd_size_type amt = sizeof (*ent);
5136       ent = bfd_alloc (abfd, amt);
5137       if (ent == NULL)
5138         return FALSE;
5139       ent->next = *plist;
5140       ent->addend = addend;
5141       ent->plt.refcount = 0;
5142       *plist = ent;
5143     }
5144   ent->plt.refcount += 1;
5145   return TRUE;
5146 }
5147
5148 static bfd_boolean
5149 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5150 {
5151   return (r_type == R_PPC64_REL24
5152           || r_type == R_PPC64_REL14
5153           || r_type == R_PPC64_REL14_BRTAKEN
5154           || r_type == R_PPC64_REL14_BRNTAKEN
5155           || r_type == R_PPC64_ADDR24
5156           || r_type == R_PPC64_ADDR14
5157           || r_type == R_PPC64_ADDR14_BRTAKEN
5158           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5159 }
5160
5161 /* Look through the relocs for a section during the first phase, and
5162    calculate needed space in the global offset table, procedure
5163    linkage table, and dynamic reloc sections.  */
5164
5165 static bfd_boolean
5166 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5167                         asection *sec, const Elf_Internal_Rela *relocs)
5168 {
5169   struct ppc_link_hash_table *htab;
5170   Elf_Internal_Shdr *symtab_hdr;
5171   struct elf_link_hash_entry **sym_hashes;
5172   const Elf_Internal_Rela *rel;
5173   const Elf_Internal_Rela *rel_end;
5174   asection *sreloc;
5175   asection **opd_sym_map;
5176   struct elf_link_hash_entry *tga, *dottga;
5177
5178   if (info->relocatable)
5179     return TRUE;
5180
5181   /* Don't do anything special with non-loaded, non-alloced sections.
5182      In particular, any relocs in such sections should not affect GOT
5183      and PLT reference counting (ie. we don't allow them to create GOT
5184      or PLT entries), there's no possibility or desire to optimize TLS
5185      relocs, and there's not much point in propagating relocs to shared
5186      libs that the dynamic linker won't relocate.  */
5187   if ((sec->flags & SEC_ALLOC) == 0)
5188     return TRUE;
5189
5190   BFD_ASSERT (is_ppc64_elf (abfd));
5191
5192   htab = ppc_hash_table (info);
5193   if (htab == NULL)
5194     return FALSE;
5195
5196   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5197                               FALSE, FALSE, TRUE);
5198   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5199                                  FALSE, FALSE, TRUE);
5200   symtab_hdr = &elf_symtab_hdr (abfd);
5201   sym_hashes = elf_sym_hashes (abfd);
5202   sreloc = NULL;
5203   opd_sym_map = NULL;
5204   if (ppc64_elf_section_data (sec) != NULL
5205       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5206     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5207
5208   rel_end = relocs + sec->reloc_count;
5209   for (rel = relocs; rel < rel_end; rel++)
5210     {
5211       unsigned long r_symndx;
5212       struct elf_link_hash_entry *h;
5213       enum elf_ppc64_reloc_type r_type;
5214       int tls_type;
5215       struct _ppc64_elf_section_data *ppc64_sec;
5216       struct plt_entry **ifunc;
5217
5218       r_symndx = ELF64_R_SYM (rel->r_info);
5219       if (r_symndx < symtab_hdr->sh_info)
5220         h = NULL;
5221       else
5222         {
5223           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5224           h = elf_follow_link (h);
5225
5226           /* PR15323, ref flags aren't set for references in the same
5227              object.  */
5228           h->root.non_ir_ref = 1;
5229
5230           if (h == htab->elf.hgot)
5231             sec->has_toc_reloc = 1;
5232         }
5233
5234       tls_type = 0;
5235       ifunc = NULL;
5236       if (h != NULL)
5237         {
5238           if (h->type == STT_GNU_IFUNC)
5239             {
5240               h->needs_plt = 1;
5241               ifunc = &h->plt.plist;
5242             }
5243         }
5244       else
5245         {
5246           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5247                                                           abfd, r_symndx);
5248           if (isym == NULL)
5249             return FALSE;
5250
5251           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5252             {
5253               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5254                                              rel->r_addend, PLT_IFUNC);
5255               if (ifunc == NULL)
5256                 return FALSE;
5257             }
5258         }
5259       r_type = ELF64_R_TYPE (rel->r_info);
5260       if (is_branch_reloc (r_type))
5261         {
5262           if (h != NULL && (h == tga || h == dottga))
5263             {
5264               if (rel != relocs
5265                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5266                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5267                 /* We have a new-style __tls_get_addr call with a marker
5268                    reloc.  */
5269                 ;
5270               else
5271                 /* Mark this section as having an old-style call.  */
5272                 sec->has_tls_get_addr_call = 1;
5273             }
5274
5275           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5276           if (ifunc != NULL
5277               && !update_plt_info (abfd, ifunc, rel->r_addend))
5278             return FALSE;
5279         }
5280
5281       switch (r_type)
5282         {
5283         case R_PPC64_TLSGD:
5284         case R_PPC64_TLSLD:
5285           /* These special tls relocs tie a call to __tls_get_addr with
5286              its parameter symbol.  */
5287           break;
5288
5289         case R_PPC64_GOT_TLSLD16:
5290         case R_PPC64_GOT_TLSLD16_LO:
5291         case R_PPC64_GOT_TLSLD16_HI:
5292         case R_PPC64_GOT_TLSLD16_HA:
5293           tls_type = TLS_TLS | TLS_LD;
5294           goto dogottls;
5295
5296         case R_PPC64_GOT_TLSGD16:
5297         case R_PPC64_GOT_TLSGD16_LO:
5298         case R_PPC64_GOT_TLSGD16_HI:
5299         case R_PPC64_GOT_TLSGD16_HA:
5300           tls_type = TLS_TLS | TLS_GD;
5301           goto dogottls;
5302
5303         case R_PPC64_GOT_TPREL16_DS:
5304         case R_PPC64_GOT_TPREL16_LO_DS:
5305         case R_PPC64_GOT_TPREL16_HI:
5306         case R_PPC64_GOT_TPREL16_HA:
5307           if (!info->executable)
5308             info->flags |= DF_STATIC_TLS;
5309           tls_type = TLS_TLS | TLS_TPREL;
5310           goto dogottls;
5311
5312         case R_PPC64_GOT_DTPREL16_DS:
5313         case R_PPC64_GOT_DTPREL16_LO_DS:
5314         case R_PPC64_GOT_DTPREL16_HI:
5315         case R_PPC64_GOT_DTPREL16_HA:
5316           tls_type = TLS_TLS | TLS_DTPREL;
5317         dogottls:
5318           sec->has_tls_reloc = 1;
5319           /* Fall thru */
5320
5321         case R_PPC64_GOT16:
5322         case R_PPC64_GOT16_DS:
5323         case R_PPC64_GOT16_HA:
5324         case R_PPC64_GOT16_HI:
5325         case R_PPC64_GOT16_LO:
5326         case R_PPC64_GOT16_LO_DS:
5327           /* This symbol requires a global offset table entry.  */
5328           sec->has_toc_reloc = 1;
5329           if (r_type == R_PPC64_GOT_TLSLD16
5330               || r_type == R_PPC64_GOT_TLSGD16
5331               || r_type == R_PPC64_GOT_TPREL16_DS
5332               || r_type == R_PPC64_GOT_DTPREL16_DS
5333               || r_type == R_PPC64_GOT16
5334               || r_type == R_PPC64_GOT16_DS)
5335             {
5336               htab->do_multi_toc = 1;
5337               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5338             }
5339
5340           if (ppc64_elf_tdata (abfd)->got == NULL
5341               && !create_got_section (abfd, info))
5342             return FALSE;
5343
5344           if (h != NULL)
5345             {
5346               struct ppc_link_hash_entry *eh;
5347               struct got_entry *ent;
5348
5349               eh = (struct ppc_link_hash_entry *) h;
5350               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5351                 if (ent->addend == rel->r_addend
5352                     && ent->owner == abfd
5353                     && ent->tls_type == tls_type)
5354                   break;
5355               if (ent == NULL)
5356                 {
5357                   bfd_size_type amt = sizeof (*ent);
5358                   ent = bfd_alloc (abfd, amt);
5359                   if (ent == NULL)
5360                     return FALSE;
5361                   ent->next = eh->elf.got.glist;
5362                   ent->addend = rel->r_addend;
5363                   ent->owner = abfd;
5364                   ent->tls_type = tls_type;
5365                   ent->is_indirect = FALSE;
5366                   ent->got.refcount = 0;
5367                   eh->elf.got.glist = ent;
5368                 }
5369               ent->got.refcount += 1;
5370               eh->tls_mask |= tls_type;
5371             }
5372           else
5373             /* This is a global offset table entry for a local symbol.  */
5374             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5375                                         rel->r_addend, tls_type))
5376               return FALSE;
5377
5378           /* We may also need a plt entry if the symbol turns out to be
5379              an ifunc.  */
5380           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5381             {
5382               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5383                 return FALSE;
5384             }
5385           break;
5386
5387         case R_PPC64_PLT16_HA:
5388         case R_PPC64_PLT16_HI:
5389         case R_PPC64_PLT16_LO:
5390         case R_PPC64_PLT32:
5391         case R_PPC64_PLT64:
5392           /* This symbol requires a procedure linkage table entry.  We
5393              actually build the entry in adjust_dynamic_symbol,
5394              because this might be a case of linking PIC code without
5395              linking in any dynamic objects, in which case we don't
5396              need to generate a procedure linkage table after all.  */
5397           if (h == NULL)
5398             {
5399               /* It does not make sense to have a procedure linkage
5400                  table entry for a local symbol.  */
5401               bfd_set_error (bfd_error_bad_value);
5402               return FALSE;
5403             }
5404           else
5405             {
5406               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5407                 return FALSE;
5408               h->needs_plt = 1;
5409               if (h->root.root.string[0] == '.'
5410                   && h->root.root.string[1] != '\0')
5411                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5412             }
5413           break;
5414
5415           /* The following relocations don't need to propagate the
5416              relocation if linking a shared object since they are
5417              section relative.  */
5418         case R_PPC64_SECTOFF:
5419         case R_PPC64_SECTOFF_LO:
5420         case R_PPC64_SECTOFF_HI:
5421         case R_PPC64_SECTOFF_HA:
5422         case R_PPC64_SECTOFF_DS:
5423         case R_PPC64_SECTOFF_LO_DS:
5424         case R_PPC64_DTPREL16:
5425         case R_PPC64_DTPREL16_LO:
5426         case R_PPC64_DTPREL16_HI:
5427         case R_PPC64_DTPREL16_HA:
5428         case R_PPC64_DTPREL16_DS:
5429         case R_PPC64_DTPREL16_LO_DS:
5430         case R_PPC64_DTPREL16_HIGH:
5431         case R_PPC64_DTPREL16_HIGHA:
5432         case R_PPC64_DTPREL16_HIGHER:
5433         case R_PPC64_DTPREL16_HIGHERA:
5434         case R_PPC64_DTPREL16_HIGHEST:
5435         case R_PPC64_DTPREL16_HIGHESTA:
5436           break;
5437
5438           /* Nor do these.  */
5439         case R_PPC64_REL16:
5440         case R_PPC64_REL16_LO:
5441         case R_PPC64_REL16_HI:
5442         case R_PPC64_REL16_HA:
5443           break;
5444
5445           /* Not supported as a dynamic relocation.  */
5446         case R_PPC64_ADDR64_LOCAL:
5447           if (info->shared)
5448             {
5449               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5450                 ppc_howto_init ();
5451               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5452                                         "in shared libraries and PIEs.\n"),
5453                                       abfd, sec, rel->r_offset,
5454                                       ppc64_elf_howto_table[r_type]->name);
5455               bfd_set_error (bfd_error_bad_value);
5456               return FALSE;
5457             }
5458           break;
5459
5460         case R_PPC64_TOC16:
5461         case R_PPC64_TOC16_DS:
5462           htab->do_multi_toc = 1;
5463           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5464         case R_PPC64_TOC16_LO:
5465         case R_PPC64_TOC16_HI:
5466         case R_PPC64_TOC16_HA:
5467         case R_PPC64_TOC16_LO_DS:
5468           sec->has_toc_reloc = 1;
5469           break;
5470
5471           /* This relocation describes the C++ object vtable hierarchy.
5472              Reconstruct it for later use during GC.  */
5473         case R_PPC64_GNU_VTINHERIT:
5474           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5475             return FALSE;
5476           break;
5477
5478           /* This relocation describes which C++ vtable entries are actually
5479              used.  Record for later use during GC.  */
5480         case R_PPC64_GNU_VTENTRY:
5481           BFD_ASSERT (h != NULL);
5482           if (h != NULL
5483               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5484             return FALSE;
5485           break;
5486
5487         case R_PPC64_REL14:
5488         case R_PPC64_REL14_BRTAKEN:
5489         case R_PPC64_REL14_BRNTAKEN:
5490           {
5491             asection *dest = NULL;
5492
5493             /* Heuristic: If jumping outside our section, chances are
5494                we are going to need a stub.  */
5495             if (h != NULL)
5496               {
5497                 /* If the sym is weak it may be overridden later, so
5498                    don't assume we know where a weak sym lives.  */
5499                 if (h->root.type == bfd_link_hash_defined)
5500                   dest = h->root.u.def.section;
5501               }
5502             else
5503               {
5504                 Elf_Internal_Sym *isym;
5505
5506                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5507                                               abfd, r_symndx);
5508                 if (isym == NULL)
5509                   return FALSE;
5510
5511                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5512               }
5513
5514             if (dest != sec)
5515               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5516           }
5517           /* Fall through.  */
5518
5519         case R_PPC64_REL24:
5520           if (h != NULL && ifunc == NULL)
5521             {
5522               /* We may need a .plt entry if the function this reloc
5523                  refers to is in a shared lib.  */
5524               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5525                 return FALSE;
5526               h->needs_plt = 1;
5527               if (h->root.root.string[0] == '.'
5528                   && h->root.root.string[1] != '\0')
5529                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5530               if (h == tga || h == dottga)
5531                 sec->has_tls_reloc = 1;
5532             }
5533           break;
5534
5535         case R_PPC64_TPREL64:
5536           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5537           if (!info->executable)
5538             info->flags |= DF_STATIC_TLS;
5539           goto dotlstoc;
5540
5541         case R_PPC64_DTPMOD64:
5542           if (rel + 1 < rel_end
5543               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5544               && rel[1].r_offset == rel->r_offset + 8)
5545             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5546           else
5547             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5548           goto dotlstoc;
5549
5550         case R_PPC64_DTPREL64:
5551           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5552           if (rel != relocs
5553               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5554               && rel[-1].r_offset == rel->r_offset - 8)
5555             /* This is the second reloc of a dtpmod, dtprel pair.
5556                Don't mark with TLS_DTPREL.  */
5557             goto dodyn;
5558
5559         dotlstoc:
5560           sec->has_tls_reloc = 1;
5561           if (h != NULL)
5562             {
5563               struct ppc_link_hash_entry *eh;
5564               eh = (struct ppc_link_hash_entry *) h;
5565               eh->tls_mask |= tls_type;
5566             }
5567           else
5568             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5569                                         rel->r_addend, tls_type))
5570               return FALSE;
5571
5572           ppc64_sec = ppc64_elf_section_data (sec);
5573           if (ppc64_sec->sec_type != sec_toc)
5574             {
5575               bfd_size_type amt;
5576
5577               /* One extra to simplify get_tls_mask.  */
5578               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5579               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5580               if (ppc64_sec->u.toc.symndx == NULL)
5581                 return FALSE;
5582               amt = sec->size * sizeof (bfd_vma) / 8;
5583               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5584               if (ppc64_sec->u.toc.add == NULL)
5585                 return FALSE;
5586               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5587               ppc64_sec->sec_type = sec_toc;
5588             }
5589           BFD_ASSERT (rel->r_offset % 8 == 0);
5590           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5591           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5592
5593           /* Mark the second slot of a GD or LD entry.
5594              -1 to indicate GD and -2 to indicate LD.  */
5595           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5596             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5597           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5598             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5599           goto dodyn;
5600
5601         case R_PPC64_TPREL16:
5602         case R_PPC64_TPREL16_LO:
5603         case R_PPC64_TPREL16_HI:
5604         case R_PPC64_TPREL16_HA:
5605         case R_PPC64_TPREL16_DS:
5606         case R_PPC64_TPREL16_LO_DS:
5607         case R_PPC64_TPREL16_HIGH:
5608         case R_PPC64_TPREL16_HIGHA:
5609         case R_PPC64_TPREL16_HIGHER:
5610         case R_PPC64_TPREL16_HIGHERA:
5611         case R_PPC64_TPREL16_HIGHEST:
5612         case R_PPC64_TPREL16_HIGHESTA:
5613           if (info->shared)
5614             {
5615               if (!info->executable)
5616                 info->flags |= DF_STATIC_TLS;
5617               goto dodyn;
5618             }
5619           break;
5620
5621         case R_PPC64_ADDR64:
5622           if (opd_sym_map != NULL
5623               && rel + 1 < rel_end
5624               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5625             {
5626               if (h != NULL)
5627                 {
5628                   if (h->root.root.string[0] == '.'
5629                       && h->root.root.string[1] != 0
5630                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5631                     ;
5632                   else
5633                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5634                 }
5635               else
5636                 {
5637                   asection *s;
5638                   Elf_Internal_Sym *isym;
5639
5640                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5641                                                 abfd, r_symndx);
5642                   if (isym == NULL)
5643                     return FALSE;
5644
5645                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5646                   if (s != NULL && s != sec)
5647                     opd_sym_map[rel->r_offset / 8] = s;
5648                 }
5649             }
5650           /* Fall through.  */
5651
5652         case R_PPC64_ADDR16:
5653         case R_PPC64_ADDR16_DS:
5654         case R_PPC64_ADDR16_HA:
5655         case R_PPC64_ADDR16_HI:
5656         case R_PPC64_ADDR16_HIGH:
5657         case R_PPC64_ADDR16_HIGHA:
5658         case R_PPC64_ADDR16_HIGHER:
5659         case R_PPC64_ADDR16_HIGHERA:
5660         case R_PPC64_ADDR16_HIGHEST:
5661         case R_PPC64_ADDR16_HIGHESTA:
5662         case R_PPC64_ADDR16_LO:
5663         case R_PPC64_ADDR16_LO_DS:
5664           if (h != NULL && !info->shared && abiversion (abfd) != 1
5665               && rel->r_addend == 0)
5666             {
5667               /* We may need a .plt entry if this reloc refers to a
5668                  function in a shared lib.  */
5669               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5670                 return FALSE;
5671               h->pointer_equality_needed = 1;
5672             }
5673           /* Fall through.  */
5674
5675         case R_PPC64_REL30:
5676         case R_PPC64_REL32:
5677         case R_PPC64_REL64:
5678         case R_PPC64_ADDR14:
5679         case R_PPC64_ADDR14_BRNTAKEN:
5680         case R_PPC64_ADDR14_BRTAKEN:
5681         case R_PPC64_ADDR24:
5682         case R_PPC64_ADDR32:
5683         case R_PPC64_UADDR16:
5684         case R_PPC64_UADDR32:
5685         case R_PPC64_UADDR64:
5686         case R_PPC64_TOC:
5687           if (h != NULL && !info->shared)
5688             /* We may need a copy reloc.  */
5689             h->non_got_ref = 1;
5690
5691           /* Don't propagate .opd relocs.  */
5692           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5693             break;
5694
5695           /* If we are creating a shared library, and this is a reloc
5696              against a global symbol, or a non PC relative reloc
5697              against a local symbol, then we need to copy the reloc
5698              into the shared library.  However, if we are linking with
5699              -Bsymbolic, we do not need to copy a reloc against a
5700              global symbol which is defined in an object we are
5701              including in the link (i.e., DEF_REGULAR is set).  At
5702              this point we have not seen all the input files, so it is
5703              possible that DEF_REGULAR is not set now but will be set
5704              later (it is never cleared).  In case of a weak definition,
5705              DEF_REGULAR may be cleared later by a strong definition in
5706              a shared library.  We account for that possibility below by
5707              storing information in the dyn_relocs field of the hash
5708              table entry.  A similar situation occurs when creating
5709              shared libraries and symbol visibility changes render the
5710              symbol local.
5711
5712              If on the other hand, we are creating an executable, we
5713              may need to keep relocations for symbols satisfied by a
5714              dynamic library if we manage to avoid copy relocs for the
5715              symbol.  */
5716         dodyn:
5717           if ((info->shared
5718                && (must_be_dyn_reloc (info, r_type)
5719                    || (h != NULL
5720                        && (!SYMBOLIC_BIND (info, h)
5721                            || h->root.type == bfd_link_hash_defweak
5722                            || !h->def_regular))))
5723               || (ELIMINATE_COPY_RELOCS
5724                   && !info->shared
5725                   && h != NULL
5726                   && (h->root.type == bfd_link_hash_defweak
5727                       || !h->def_regular))
5728               || (!info->shared
5729                   && ifunc != NULL))
5730             {
5731               /* We must copy these reloc types into the output file.
5732                  Create a reloc section in dynobj and make room for
5733                  this reloc.  */
5734               if (sreloc == NULL)
5735                 {
5736                   sreloc = _bfd_elf_make_dynamic_reloc_section
5737                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5738
5739                   if (sreloc == NULL)
5740                     return FALSE;
5741                 }
5742
5743               /* If this is a global symbol, we count the number of
5744                  relocations we need for this symbol.  */
5745               if (h != NULL)
5746                 {
5747                   struct elf_dyn_relocs *p;
5748                   struct elf_dyn_relocs **head;
5749
5750                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5751                   p = *head;
5752                   if (p == NULL || p->sec != sec)
5753                     {
5754                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5755                       if (p == NULL)
5756                         return FALSE;
5757                       p->next = *head;
5758                       *head = p;
5759                       p->sec = sec;
5760                       p->count = 0;
5761                       p->pc_count = 0;
5762                     }
5763                   p->count += 1;
5764                   if (!must_be_dyn_reloc (info, r_type))
5765                     p->pc_count += 1;
5766                 }
5767               else
5768                 {
5769                   /* Track dynamic relocs needed for local syms too.
5770                      We really need local syms available to do this
5771                      easily.  Oh well.  */
5772                   struct ppc_dyn_relocs *p;
5773                   struct ppc_dyn_relocs **head;
5774                   bfd_boolean is_ifunc;
5775                   asection *s;
5776                   void *vpp;
5777                   Elf_Internal_Sym *isym;
5778
5779                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5780                                                 abfd, r_symndx);
5781                   if (isym == NULL)
5782                     return FALSE;
5783
5784                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5785                   if (s == NULL)
5786                     s = sec;
5787
5788                   vpp = &elf_section_data (s)->local_dynrel;
5789                   head = (struct ppc_dyn_relocs **) vpp;
5790                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5791                   p = *head;
5792                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5793                     p = p->next;
5794                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5795                     {
5796                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5797                       if (p == NULL)
5798                         return FALSE;
5799                       p->next = *head;
5800                       *head = p;
5801                       p->sec = sec;
5802                       p->ifunc = is_ifunc;
5803                       p->count = 0;
5804                     }
5805                   p->count += 1;
5806                 }
5807             }
5808           break;
5809
5810         default:
5811           break;
5812         }
5813     }
5814
5815   return TRUE;
5816 }
5817
5818 /* Merge backend specific data from an object file to the output
5819    object file when linking.  */
5820
5821 static bfd_boolean
5822 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5823 {
5824   unsigned long iflags, oflags;
5825
5826   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5827     return TRUE;
5828
5829   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5830     return TRUE;
5831
5832   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5833     return FALSE;
5834
5835   iflags = elf_elfheader (ibfd)->e_flags;
5836   oflags = elf_elfheader (obfd)->e_flags;
5837
5838   if (iflags & ~EF_PPC64_ABI)
5839     {
5840       (*_bfd_error_handler)
5841         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5842       bfd_set_error (bfd_error_bad_value);
5843       return FALSE;
5844     }
5845   else if (iflags != oflags && iflags != 0)
5846     {
5847       (*_bfd_error_handler)
5848         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5849          ibfd, iflags, oflags);
5850       bfd_set_error (bfd_error_bad_value);
5851       return FALSE;
5852     }
5853
5854   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5855   _bfd_elf_merge_object_attributes (ibfd, obfd);
5856
5857   return TRUE;
5858 }
5859
5860 static bfd_boolean
5861 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5862 {
5863   /* Print normal ELF private data.  */
5864   _bfd_elf_print_private_bfd_data (abfd, ptr);
5865
5866   if (elf_elfheader (abfd)->e_flags != 0)
5867     {
5868       FILE *file = ptr;
5869
5870       /* xgettext:c-format */
5871       fprintf (file, _("private flags = 0x%lx:"),
5872                elf_elfheader (abfd)->e_flags);
5873
5874       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5875         fprintf (file, _(" [abiv%ld]"),
5876                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5877       fputc ('\n', file);
5878     }
5879
5880   return TRUE;
5881 }
5882
5883 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5884    of the code entry point, and its section.  */
5885
5886 static bfd_vma
5887 opd_entry_value (asection *opd_sec,
5888                  bfd_vma offset,
5889                  asection **code_sec,
5890                  bfd_vma *code_off,
5891                  bfd_boolean in_code_sec)
5892 {
5893   bfd *opd_bfd = opd_sec->owner;
5894   Elf_Internal_Rela *relocs;
5895   Elf_Internal_Rela *lo, *hi, *look;
5896   bfd_vma val;
5897
5898   /* No relocs implies we are linking a --just-symbols object, or looking
5899      at a final linked executable with addr2line or somesuch.  */
5900   if (opd_sec->reloc_count == 0)
5901     {
5902       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5903
5904       if (contents == NULL)
5905         {
5906           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5907             return (bfd_vma) -1;
5908           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5909         }
5910
5911       val = bfd_get_64 (opd_bfd, contents + offset);
5912       if (code_sec != NULL)
5913         {
5914           asection *sec, *likely = NULL;
5915
5916           if (in_code_sec)
5917             {
5918               sec = *code_sec;
5919               if (sec->vma <= val
5920                   && val < sec->vma + sec->size)
5921                 likely = sec;
5922               else
5923                 val = -1;
5924             }
5925           else
5926             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5927               if (sec->vma <= val
5928                   && (sec->flags & SEC_LOAD) != 0
5929                   && (sec->flags & SEC_ALLOC) != 0)
5930                 likely = sec;
5931           if (likely != NULL)
5932             {
5933               *code_sec = likely;
5934               if (code_off != NULL)
5935                 *code_off = val - likely->vma;
5936             }
5937         }
5938       return val;
5939     }
5940
5941   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5942
5943   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5944   if (relocs == NULL)
5945     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5946
5947   /* Go find the opd reloc at the sym address.  */
5948   lo = relocs;
5949   BFD_ASSERT (lo != NULL);
5950   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5951   val = (bfd_vma) -1;
5952   while (lo < hi)
5953     {
5954       look = lo + (hi - lo) / 2;
5955       if (look->r_offset < offset)
5956         lo = look + 1;
5957       else if (look->r_offset > offset)
5958         hi = look;
5959       else
5960         {
5961           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5962
5963           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5964               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5965             {
5966               unsigned long symndx = ELF64_R_SYM (look->r_info);
5967               asection *sec;
5968
5969               if (symndx < symtab_hdr->sh_info
5970                   || elf_sym_hashes (opd_bfd) == NULL)
5971                 {
5972                   Elf_Internal_Sym *sym;
5973
5974                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5975                   if (sym == NULL)
5976                     {
5977                       size_t symcnt = symtab_hdr->sh_info;
5978                       if (elf_sym_hashes (opd_bfd) == NULL)
5979                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5980                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5981                                                   0, NULL, NULL, NULL);
5982                       if (sym == NULL)
5983                         break;
5984                       symtab_hdr->contents = (bfd_byte *) sym;
5985                     }
5986
5987                   sym += symndx;
5988                   val = sym->st_value;
5989                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5990                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5991                 }
5992               else
5993                 {
5994                   struct elf_link_hash_entry **sym_hashes;
5995                   struct elf_link_hash_entry *rh;
5996
5997                   sym_hashes = elf_sym_hashes (opd_bfd);
5998                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5999                   if (rh != NULL)
6000                     {
6001                       rh = elf_follow_link (rh);
6002                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6003                                   || rh->root.type == bfd_link_hash_defweak);
6004                       val = rh->root.u.def.value;
6005                       sec = rh->root.u.def.section;
6006                     }
6007                   else
6008                     {
6009                       /* Handle the odd case where we can be called
6010                          during bfd_elf_link_add_symbols before the
6011                          symbol hashes have been fully populated.  */
6012                       Elf_Internal_Sym *sym;
6013
6014                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6015                                                   symndx, NULL, NULL, NULL);
6016                       if (sym == NULL)
6017                         break;
6018
6019                       val = sym->st_value;
6020                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6021                       free (sym);
6022                     }
6023                 }
6024               val += look->r_addend;
6025               if (code_off != NULL)
6026                 *code_off = val;
6027               if (code_sec != NULL)
6028                 {
6029                   if (in_code_sec && *code_sec != sec)
6030                     return -1;
6031                   else
6032                     *code_sec = sec;
6033                 }
6034               if (sec != NULL && sec->output_section != NULL)
6035                 val += sec->output_section->vma + sec->output_offset;
6036             }
6037           break;
6038         }
6039     }
6040
6041   return val;
6042 }
6043
6044 /* If the ELF symbol SYM might be a function in SEC, return the
6045    function size and set *CODE_OFF to the function's entry point,
6046    otherwise return zero.  */
6047
6048 static bfd_size_type
6049 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6050                               bfd_vma *code_off)
6051 {
6052   bfd_size_type size;
6053
6054   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6055                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6056     return 0;
6057
6058   size = 0;
6059   if (!(sym->flags & BSF_SYNTHETIC))
6060     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6061
6062   if (strcmp (sym->section->name, ".opd") == 0)
6063     {
6064       if (opd_entry_value (sym->section, sym->value,
6065                            &sec, code_off, TRUE) == (bfd_vma) -1)
6066         return 0;
6067       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6068          symbol.  This size has nothing to do with the code size of the
6069          function, which is what we're supposed to return, but the
6070          code size isn't available without looking up the dot-sym.
6071          However, doing that would be a waste of time particularly
6072          since elf_find_function will look at the dot-sym anyway.
6073          Now, elf_find_function will keep the largest size of any
6074          function sym found at the code address of interest, so return
6075          1 here to avoid it incorrectly caching a larger function size
6076          for a small function.  This does mean we return the wrong
6077          size for a new-ABI function of size 24, but all that does is
6078          disable caching for such functions.  */
6079       if (size == 24)
6080         size = 1;
6081     }
6082   else
6083     {
6084       if (sym->section != sec)
6085         return 0;
6086       *code_off = sym->value;
6087     }
6088   if (size == 0)
6089     size = 1;
6090   return size;
6091 }
6092
6093 /* Return true if symbol is defined in a regular object file.  */
6094
6095 static bfd_boolean
6096 is_static_defined (struct elf_link_hash_entry *h)
6097 {
6098   return ((h->root.type == bfd_link_hash_defined
6099            || h->root.type == bfd_link_hash_defweak)
6100           && h->root.u.def.section != NULL
6101           && h->root.u.def.section->output_section != NULL);
6102 }
6103
6104 /* If FDH is a function descriptor symbol, return the associated code
6105    entry symbol if it is defined.  Return NULL otherwise.  */
6106
6107 static struct ppc_link_hash_entry *
6108 defined_code_entry (struct ppc_link_hash_entry *fdh)
6109 {
6110   if (fdh->is_func_descriptor)
6111     {
6112       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6113       if (fh->elf.root.type == bfd_link_hash_defined
6114           || fh->elf.root.type == bfd_link_hash_defweak)
6115         return fh;
6116     }
6117   return NULL;
6118 }
6119
6120 /* If FH is a function code entry symbol, return the associated
6121    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6122
6123 static struct ppc_link_hash_entry *
6124 defined_func_desc (struct ppc_link_hash_entry *fh)
6125 {
6126   if (fh->oh != NULL
6127       && fh->oh->is_func_descriptor)
6128     {
6129       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6130       if (fdh->elf.root.type == bfd_link_hash_defined
6131           || fdh->elf.root.type == bfd_link_hash_defweak)
6132         return fdh;
6133     }
6134   return NULL;
6135 }
6136
6137 /* Mark all our entry sym sections, both opd and code section.  */
6138
6139 static void
6140 ppc64_elf_gc_keep (struct bfd_link_info *info)
6141 {
6142   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6143   struct bfd_sym_chain *sym;
6144
6145   if (htab == NULL)
6146     return;
6147
6148   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6149     {
6150       struct ppc_link_hash_entry *eh, *fh;
6151       asection *sec;
6152
6153       eh = (struct ppc_link_hash_entry *)
6154         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6155       if (eh == NULL)
6156         continue;
6157       if (eh->elf.root.type != bfd_link_hash_defined
6158           && eh->elf.root.type != bfd_link_hash_defweak)
6159         continue;
6160
6161       fh = defined_code_entry (eh);
6162       if (fh != NULL)
6163         {
6164           sec = fh->elf.root.u.def.section;
6165           sec->flags |= SEC_KEEP;
6166         }
6167       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6168                && opd_entry_value (eh->elf.root.u.def.section,
6169                                    eh->elf.root.u.def.value,
6170                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6171         sec->flags |= SEC_KEEP;
6172
6173       sec = eh->elf.root.u.def.section;
6174       sec->flags |= SEC_KEEP;
6175     }
6176 }
6177
6178 /* Mark sections containing dynamically referenced symbols.  When
6179    building shared libraries, we must assume that any visible symbol is
6180    referenced.  */
6181
6182 static bfd_boolean
6183 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6184 {
6185   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6186   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6187   struct ppc_link_hash_entry *fdh;
6188   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6189
6190   /* Dynamic linking info is on the func descriptor sym.  */
6191   fdh = defined_func_desc (eh);
6192   if (fdh != NULL)
6193     eh = fdh;
6194
6195   if ((eh->elf.root.type == bfd_link_hash_defined
6196        || eh->elf.root.type == bfd_link_hash_defweak)
6197       && (eh->elf.ref_dynamic
6198           || (eh->elf.def_regular
6199               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6200               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6201               && (!info->executable
6202                   || info->export_dynamic
6203                   || (eh->elf.dynamic
6204                       && d != NULL
6205                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6206               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6207                   || !bfd_hide_sym_by_version (info->version_info,
6208                                                eh->elf.root.root.string)))))
6209     {
6210       asection *code_sec;
6211       struct ppc_link_hash_entry *fh;
6212
6213       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6214
6215       /* Function descriptor syms cause the associated
6216          function code sym section to be marked.  */
6217       fh = defined_code_entry (eh);
6218       if (fh != NULL)
6219         {
6220           code_sec = fh->elf.root.u.def.section;
6221           code_sec->flags |= SEC_KEEP;
6222         }
6223       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6224                && opd_entry_value (eh->elf.root.u.def.section,
6225                                    eh->elf.root.u.def.value,
6226                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6227         code_sec->flags |= SEC_KEEP;
6228     }
6229
6230   return TRUE;
6231 }
6232
6233 /* Return the section that should be marked against GC for a given
6234    relocation.  */
6235
6236 static asection *
6237 ppc64_elf_gc_mark_hook (asection *sec,
6238                         struct bfd_link_info *info,
6239                         Elf_Internal_Rela *rel,
6240                         struct elf_link_hash_entry *h,
6241                         Elf_Internal_Sym *sym)
6242 {
6243   asection *rsec;
6244
6245   /* Syms return NULL if we're marking .opd, so we avoid marking all
6246      function sections, as all functions are referenced in .opd.  */
6247   rsec = NULL;
6248   if (get_opd_info (sec) != NULL)
6249     return rsec;
6250
6251   if (h != NULL)
6252     {
6253       enum elf_ppc64_reloc_type r_type;
6254       struct ppc_link_hash_entry *eh, *fh, *fdh;
6255
6256       r_type = ELF64_R_TYPE (rel->r_info);
6257       switch (r_type)
6258         {
6259         case R_PPC64_GNU_VTINHERIT:
6260         case R_PPC64_GNU_VTENTRY:
6261           break;
6262
6263         default:
6264           switch (h->root.type)
6265             {
6266             case bfd_link_hash_defined:
6267             case bfd_link_hash_defweak:
6268               eh = (struct ppc_link_hash_entry *) h;
6269               fdh = defined_func_desc (eh);
6270               if (fdh != NULL)
6271                 eh = fdh;
6272
6273               /* Function descriptor syms cause the associated
6274                  function code sym section to be marked.  */
6275               fh = defined_code_entry (eh);
6276               if (fh != NULL)
6277                 {
6278                   /* They also mark their opd section.  */
6279                   eh->elf.root.u.def.section->gc_mark = 1;
6280
6281                   rsec = fh->elf.root.u.def.section;
6282                 }
6283               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6284                        && opd_entry_value (eh->elf.root.u.def.section,
6285                                            eh->elf.root.u.def.value,
6286                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6287                 eh->elf.root.u.def.section->gc_mark = 1;
6288               else
6289                 rsec = h->root.u.def.section;
6290               break;
6291
6292             case bfd_link_hash_common:
6293               rsec = h->root.u.c.p->section;
6294               break;
6295
6296             default:
6297               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6298             }
6299         }
6300     }
6301   else
6302     {
6303       struct _opd_sec_data *opd;
6304
6305       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6306       opd = get_opd_info (rsec);
6307       if (opd != NULL && opd->func_sec != NULL)
6308         {
6309           rsec->gc_mark = 1;
6310
6311           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6312         }
6313     }
6314
6315   return rsec;
6316 }
6317
6318 /* Update the .got, .plt. and dynamic reloc reference counts for the
6319    section being removed.  */
6320
6321 static bfd_boolean
6322 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6323                          asection *sec, const Elf_Internal_Rela *relocs)
6324 {
6325   struct ppc_link_hash_table *htab;
6326   Elf_Internal_Shdr *symtab_hdr;
6327   struct elf_link_hash_entry **sym_hashes;
6328   struct got_entry **local_got_ents;
6329   const Elf_Internal_Rela *rel, *relend;
6330
6331   if (info->relocatable)
6332     return TRUE;
6333
6334   if ((sec->flags & SEC_ALLOC) == 0)
6335     return TRUE;
6336
6337   elf_section_data (sec)->local_dynrel = NULL;
6338
6339   htab = ppc_hash_table (info);
6340   if (htab == NULL)
6341     return FALSE;
6342
6343   symtab_hdr = &elf_symtab_hdr (abfd);
6344   sym_hashes = elf_sym_hashes (abfd);
6345   local_got_ents = elf_local_got_ents (abfd);
6346
6347   relend = relocs + sec->reloc_count;
6348   for (rel = relocs; rel < relend; rel++)
6349     {
6350       unsigned long r_symndx;
6351       enum elf_ppc64_reloc_type r_type;
6352       struct elf_link_hash_entry *h = NULL;
6353       unsigned char tls_type = 0;
6354
6355       r_symndx = ELF64_R_SYM (rel->r_info);
6356       r_type = ELF64_R_TYPE (rel->r_info);
6357       if (r_symndx >= symtab_hdr->sh_info)
6358         {
6359           struct ppc_link_hash_entry *eh;
6360           struct elf_dyn_relocs **pp;
6361           struct elf_dyn_relocs *p;
6362
6363           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6364           h = elf_follow_link (h);
6365           eh = (struct ppc_link_hash_entry *) h;
6366
6367           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6368             if (p->sec == sec)
6369               {
6370                 /* Everything must go for SEC.  */
6371                 *pp = p->next;
6372                 break;
6373               }
6374         }
6375
6376       if (is_branch_reloc (r_type))
6377         {
6378           struct plt_entry **ifunc = NULL;
6379           if (h != NULL)
6380             {
6381               if (h->type == STT_GNU_IFUNC)
6382                 ifunc = &h->plt.plist;
6383             }
6384           else if (local_got_ents != NULL)
6385             {
6386               struct plt_entry **local_plt = (struct plt_entry **)
6387                 (local_got_ents + symtab_hdr->sh_info);
6388               unsigned char *local_got_tls_masks = (unsigned char *)
6389                 (local_plt + symtab_hdr->sh_info);
6390               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6391                 ifunc = local_plt + r_symndx;
6392             }
6393           if (ifunc != NULL)
6394             {
6395               struct plt_entry *ent;
6396
6397               for (ent = *ifunc; ent != NULL; ent = ent->next)
6398                 if (ent->addend == rel->r_addend)
6399                   break;
6400               if (ent == NULL)
6401                 abort ();
6402               if (ent->plt.refcount > 0)
6403                 ent->plt.refcount -= 1;
6404               continue;
6405             }
6406         }
6407
6408       switch (r_type)
6409         {
6410         case R_PPC64_GOT_TLSLD16:
6411         case R_PPC64_GOT_TLSLD16_LO:
6412         case R_PPC64_GOT_TLSLD16_HI:
6413         case R_PPC64_GOT_TLSLD16_HA:
6414           tls_type = TLS_TLS | TLS_LD;
6415           goto dogot;
6416
6417         case R_PPC64_GOT_TLSGD16:
6418         case R_PPC64_GOT_TLSGD16_LO:
6419         case R_PPC64_GOT_TLSGD16_HI:
6420         case R_PPC64_GOT_TLSGD16_HA:
6421           tls_type = TLS_TLS | TLS_GD;
6422           goto dogot;
6423
6424         case R_PPC64_GOT_TPREL16_DS:
6425         case R_PPC64_GOT_TPREL16_LO_DS:
6426         case R_PPC64_GOT_TPREL16_HI:
6427         case R_PPC64_GOT_TPREL16_HA:
6428           tls_type = TLS_TLS | TLS_TPREL;
6429           goto dogot;
6430
6431         case R_PPC64_GOT_DTPREL16_DS:
6432         case R_PPC64_GOT_DTPREL16_LO_DS:
6433         case R_PPC64_GOT_DTPREL16_HI:
6434         case R_PPC64_GOT_DTPREL16_HA:
6435           tls_type = TLS_TLS | TLS_DTPREL;
6436           goto dogot;
6437
6438         case R_PPC64_GOT16:
6439         case R_PPC64_GOT16_DS:
6440         case R_PPC64_GOT16_HA:
6441         case R_PPC64_GOT16_HI:
6442         case R_PPC64_GOT16_LO:
6443         case R_PPC64_GOT16_LO_DS:
6444         dogot:
6445           {
6446             struct got_entry *ent;
6447
6448             if (h != NULL)
6449               ent = h->got.glist;
6450             else
6451               ent = local_got_ents[r_symndx];
6452
6453             for (; ent != NULL; ent = ent->next)
6454               if (ent->addend == rel->r_addend
6455                   && ent->owner == abfd
6456                   && ent->tls_type == tls_type)
6457                 break;
6458             if (ent == NULL)
6459               abort ();
6460             if (ent->got.refcount > 0)
6461               ent->got.refcount -= 1;
6462           }
6463           break;
6464
6465         case R_PPC64_PLT16_HA:
6466         case R_PPC64_PLT16_HI:
6467         case R_PPC64_PLT16_LO:
6468         case R_PPC64_PLT32:
6469         case R_PPC64_PLT64:
6470         case R_PPC64_REL14:
6471         case R_PPC64_REL14_BRNTAKEN:
6472         case R_PPC64_REL14_BRTAKEN:
6473         case R_PPC64_REL24:
6474           if (h != NULL)
6475             {
6476               struct plt_entry *ent;
6477
6478               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6479                 if (ent->addend == rel->r_addend)
6480                   break;
6481               if (ent != NULL && ent->plt.refcount > 0)
6482                 ent->plt.refcount -= 1;
6483             }
6484           break;
6485
6486         default:
6487           break;
6488         }
6489     }
6490   return TRUE;
6491 }
6492
6493 /* The maximum size of .sfpr.  */
6494 #define SFPR_MAX (218*4)
6495
6496 struct sfpr_def_parms
6497 {
6498   const char name[12];
6499   unsigned char lo, hi;
6500   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6501   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6502 };
6503
6504 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6505
6506 static bfd_boolean
6507 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6508 {
6509   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6510   unsigned int i;
6511   size_t len = strlen (parm->name);
6512   bfd_boolean writing = FALSE;
6513   char sym[16];
6514
6515   if (htab == NULL)
6516     return FALSE;
6517
6518   memcpy (sym, parm->name, len);
6519   sym[len + 2] = 0;
6520
6521   for (i = parm->lo; i <= parm->hi; i++)
6522     {
6523       struct elf_link_hash_entry *h;
6524
6525       sym[len + 0] = i / 10 + '0';
6526       sym[len + 1] = i % 10 + '0';
6527       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6528       if (h != NULL
6529           && !h->def_regular)
6530         {
6531           h->root.type = bfd_link_hash_defined;
6532           h->root.u.def.section = htab->sfpr;
6533           h->root.u.def.value = htab->sfpr->size;
6534           h->type = STT_FUNC;
6535           h->def_regular = 1;
6536           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6537           writing = TRUE;
6538           if (htab->sfpr->contents == NULL)
6539             {
6540               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6541               if (htab->sfpr->contents == NULL)
6542                 return FALSE;
6543             }
6544         }
6545       if (writing)
6546         {
6547           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6548           if (i != parm->hi)
6549             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6550           else
6551             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6552           htab->sfpr->size = p - htab->sfpr->contents;
6553         }
6554     }
6555
6556   return TRUE;
6557 }
6558
6559 static bfd_byte *
6560 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6561 {
6562   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6563   return p + 4;
6564 }
6565
6566 static bfd_byte *
6567 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6568 {
6569   p = savegpr0 (abfd, p, r);
6570   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6571   p = p + 4;
6572   bfd_put_32 (abfd, BLR, p);
6573   return p + 4;
6574 }
6575
6576 static bfd_byte *
6577 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6578 {
6579   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6580   return p + 4;
6581 }
6582
6583 static bfd_byte *
6584 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6585 {
6586   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6587   p = p + 4;
6588   p = restgpr0 (abfd, p, r);
6589   bfd_put_32 (abfd, MTLR_R0, p);
6590   p = p + 4;
6591   if (r == 29)
6592     {
6593       p = restgpr0 (abfd, p, 30);
6594       p = restgpr0 (abfd, p, 31);
6595     }
6596   bfd_put_32 (abfd, BLR, p);
6597   return p + 4;
6598 }
6599
6600 static bfd_byte *
6601 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6602 {
6603   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6604   return p + 4;
6605 }
6606
6607 static bfd_byte *
6608 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6609 {
6610   p = savegpr1 (abfd, p, r);
6611   bfd_put_32 (abfd, BLR, p);
6612   return p + 4;
6613 }
6614
6615 static bfd_byte *
6616 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6617 {
6618   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6619   return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   p = restgpr1 (abfd, p, r);
6626   bfd_put_32 (abfd, BLR, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 savefpr (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6634   return p + 4;
6635 }
6636
6637 static bfd_byte *
6638 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6639 {
6640   p = savefpr (abfd, p, r);
6641   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6642   p = p + 4;
6643   bfd_put_32 (abfd, BLR, p);
6644   return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 restfpr (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6651   return p + 4;
6652 }
6653
6654 static bfd_byte *
6655 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6656 {
6657   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6658   p = p + 4;
6659   p = restfpr (abfd, p, r);
6660   bfd_put_32 (abfd, MTLR_R0, p);
6661   p = p + 4;
6662   if (r == 29)
6663     {
6664       p = restfpr (abfd, p, 30);
6665       p = restfpr (abfd, p, 31);
6666     }
6667   bfd_put_32 (abfd, BLR, p);
6668   return p + 4;
6669 }
6670
6671 static bfd_byte *
6672 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6673 {
6674   p = savefpr (abfd, p, r);
6675   bfd_put_32 (abfd, BLR, p);
6676   return p + 4;
6677 }
6678
6679 static bfd_byte *
6680 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6681 {
6682   p = restfpr (abfd, p, r);
6683   bfd_put_32 (abfd, BLR, p);
6684   return p + 4;
6685 }
6686
6687 static bfd_byte *
6688 savevr (bfd *abfd, bfd_byte *p, int r)
6689 {
6690   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6691   p = p + 4;
6692   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6693   return p + 4;
6694 }
6695
6696 static bfd_byte *
6697 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6698 {
6699   p = savevr (abfd, p, r);
6700   bfd_put_32 (abfd, BLR, p);
6701   return p + 4;
6702 }
6703
6704 static bfd_byte *
6705 restvr (bfd *abfd, bfd_byte *p, int r)
6706 {
6707   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6708   p = p + 4;
6709   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6710   return p + 4;
6711 }
6712
6713 static bfd_byte *
6714 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6715 {
6716   p = restvr (abfd, p, r);
6717   bfd_put_32 (abfd, BLR, p);
6718   return p + 4;
6719 }
6720
6721 /* Called via elf_link_hash_traverse to transfer dynamic linking
6722    information on function code symbol entries to their corresponding
6723    function descriptor symbol entries.  */
6724
6725 static bfd_boolean
6726 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6727 {
6728   struct bfd_link_info *info;
6729   struct ppc_link_hash_table *htab;
6730   struct plt_entry *ent;
6731   struct ppc_link_hash_entry *fh;
6732   struct ppc_link_hash_entry *fdh;
6733   bfd_boolean force_local;
6734
6735   fh = (struct ppc_link_hash_entry *) h;
6736   if (fh->elf.root.type == bfd_link_hash_indirect)
6737     return TRUE;
6738
6739   info = inf;
6740   htab = ppc_hash_table (info);
6741   if (htab == NULL)
6742     return FALSE;
6743
6744   /* Resolve undefined references to dot-symbols as the value
6745      in the function descriptor, if we have one in a regular object.
6746      This is to satisfy cases like ".quad .foo".  Calls to functions
6747      in dynamic objects are handled elsewhere.  */
6748   if (fh->elf.root.type == bfd_link_hash_undefweak
6749       && fh->was_undefined
6750       && (fdh = defined_func_desc (fh)) != NULL
6751       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6752       && opd_entry_value (fdh->elf.root.u.def.section,
6753                           fdh->elf.root.u.def.value,
6754                           &fh->elf.root.u.def.section,
6755                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6756     {
6757       fh->elf.root.type = fdh->elf.root.type;
6758       fh->elf.forced_local = 1;
6759       fh->elf.def_regular = fdh->elf.def_regular;
6760       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6761     }
6762
6763   /* If this is a function code symbol, transfer dynamic linking
6764      information to the function descriptor symbol.  */
6765   if (!fh->is_func)
6766     return TRUE;
6767
6768   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6769     if (ent->plt.refcount > 0)
6770       break;
6771   if (ent == NULL
6772       || fh->elf.root.root.string[0] != '.'
6773       || fh->elf.root.root.string[1] == '\0')
6774     return TRUE;
6775
6776   /* Find the corresponding function descriptor symbol.  Create it
6777      as undefined if necessary.  */
6778
6779   fdh = lookup_fdh (fh, htab);
6780   if (fdh == NULL
6781       && !info->executable
6782       && (fh->elf.root.type == bfd_link_hash_undefined
6783           || fh->elf.root.type == bfd_link_hash_undefweak))
6784     {
6785       fdh = make_fdh (info, fh);
6786       if (fdh == NULL)
6787         return FALSE;
6788     }
6789
6790   /* Fake function descriptors are made undefweak.  If the function
6791      code symbol is strong undefined, make the fake sym the same.
6792      If the function code symbol is defined, then force the fake
6793      descriptor local;  We can't support overriding of symbols in a
6794      shared library on a fake descriptor.  */
6795
6796   if (fdh != NULL
6797       && fdh->fake
6798       && fdh->elf.root.type == bfd_link_hash_undefweak)
6799     {
6800       if (fh->elf.root.type == bfd_link_hash_undefined)
6801         {
6802           fdh->elf.root.type = bfd_link_hash_undefined;
6803           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6804         }
6805       else if (fh->elf.root.type == bfd_link_hash_defined
6806                || fh->elf.root.type == bfd_link_hash_defweak)
6807         {
6808           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6809         }
6810     }
6811
6812   if (fdh != NULL
6813       && !fdh->elf.forced_local
6814       && (!info->executable
6815           || fdh->elf.def_dynamic
6816           || fdh->elf.ref_dynamic
6817           || (fdh->elf.root.type == bfd_link_hash_undefweak
6818               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6819     {
6820       if (fdh->elf.dynindx == -1)
6821         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6822           return FALSE;
6823       fdh->elf.ref_regular |= fh->elf.ref_regular;
6824       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6825       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6826       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6827       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6828         {
6829           move_plt_plist (fh, fdh);
6830           fdh->elf.needs_plt = 1;
6831         }
6832       fdh->is_func_descriptor = 1;
6833       fdh->oh = fh;
6834       fh->oh = fdh;
6835     }
6836
6837   /* Now that the info is on the function descriptor, clear the
6838      function code sym info.  Any function code syms for which we
6839      don't have a definition in a regular file, we force local.
6840      This prevents a shared library from exporting syms that have
6841      been imported from another library.  Function code syms that
6842      are really in the library we must leave global to prevent the
6843      linker dragging in a definition from a static library.  */
6844   force_local = (!fh->elf.def_regular
6845                  || fdh == NULL
6846                  || !fdh->elf.def_regular
6847                  || fdh->elf.forced_local);
6848   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6849
6850   return TRUE;
6851 }
6852
6853 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6854    this hook to a) provide some gcc support functions, and b) transfer
6855    dynamic linking information gathered so far on function code symbol
6856    entries, to their corresponding function descriptor symbol entries.  */
6857
6858 static bfd_boolean
6859 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6860                             struct bfd_link_info *info)
6861 {
6862   struct ppc_link_hash_table *htab;
6863   unsigned int i;
6864   static const struct sfpr_def_parms funcs[] =
6865     {
6866       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6867       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6868       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6869       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6870       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6871       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6872       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6873       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6874       { "._savef", 14, 31, savefpr, savefpr1_tail },
6875       { "._restf", 14, 31, restfpr, restfpr1_tail },
6876       { "_savevr_", 20, 31, savevr, savevr_tail },
6877       { "_restvr_", 20, 31, restvr, restvr_tail }
6878     };
6879
6880   htab = ppc_hash_table (info);
6881   if (htab == NULL)
6882     return FALSE;
6883
6884   if (!info->relocatable
6885       && htab->elf.hgot != NULL)
6886     {
6887       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6888       /* Make .TOC. defined so as to prevent it being made dynamic.
6889          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6890       htab->elf.hgot->type = STT_OBJECT;
6891       htab->elf.hgot->root.type = bfd_link_hash_defined;
6892       htab->elf.hgot->root.u.def.value = 0;
6893       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6894       htab->elf.hgot->def_regular = 1;
6895       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6896                                | STV_HIDDEN);
6897     }
6898
6899   if (htab->sfpr == NULL)
6900     /* We don't have any relocs.  */
6901     return TRUE;
6902
6903   /* Provide any missing _save* and _rest* functions.  */
6904   htab->sfpr->size = 0;
6905   if (htab->params->save_restore_funcs)
6906     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6907       if (!sfpr_define (info, &funcs[i]))
6908         return FALSE;
6909
6910   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6911
6912   if (htab->sfpr->size == 0)
6913     htab->sfpr->flags |= SEC_EXCLUDE;
6914
6915   return TRUE;
6916 }
6917
6918 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6919
6920 static bfd_boolean
6921 readonly_dynrelocs (struct elf_link_hash_entry *h)
6922 {
6923   struct ppc_link_hash_entry *eh;
6924   struct elf_dyn_relocs *p;
6925
6926   eh = (struct ppc_link_hash_entry *) h;
6927   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6928     {
6929       asection *s = p->sec->output_section;
6930
6931       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6932         return TRUE;
6933     }
6934   return FALSE;
6935 }
6936
6937 /* Adjust a symbol defined by a dynamic object and referenced by a
6938    regular object.  The current definition is in some section of the
6939    dynamic object, but we're not including those sections.  We have to
6940    change the definition to something the rest of the link can
6941    understand.  */
6942
6943 static bfd_boolean
6944 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6945                                  struct elf_link_hash_entry *h)
6946 {
6947   struct ppc_link_hash_table *htab;
6948   asection *s;
6949
6950   htab = ppc_hash_table (info);
6951   if (htab == NULL)
6952     return FALSE;
6953
6954   /* Deal with function syms.  */
6955   if (h->type == STT_FUNC
6956       || h->type == STT_GNU_IFUNC
6957       || h->needs_plt)
6958     {
6959       /* Clear procedure linkage table information for any symbol that
6960          won't need a .plt entry.  */
6961       struct plt_entry *ent;
6962       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6963         if (ent->plt.refcount > 0)
6964           break;
6965       if (ent == NULL
6966           || (h->type != STT_GNU_IFUNC
6967               && (SYMBOL_CALLS_LOCAL (info, h)
6968                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6969                       && h->root.type == bfd_link_hash_undefweak))))
6970         {
6971           h->plt.plist = NULL;
6972           h->needs_plt = 0;
6973         }
6974       else if (abiversion (info->output_bfd) == 2)
6975         {
6976           /* After adjust_dynamic_symbol, non_got_ref set in the
6977              non-shared case means that we have allocated space in
6978              .dynbss for the symbol and thus dyn_relocs for this
6979              symbol should be discarded.
6980              If we get here we know we are making a PLT entry for this
6981              symbol, and in an executable we'd normally resolve
6982              relocations against this symbol to the PLT entry.  Allow
6983              dynamic relocs if the reference is weak, and the dynamic
6984              relocs will not cause text relocation.  */
6985           if (!h->ref_regular_nonweak
6986               && h->non_got_ref
6987               && h->type != STT_GNU_IFUNC
6988               && !readonly_dynrelocs (h))
6989             h->non_got_ref = 0;
6990
6991           /* If making a plt entry, then we don't need copy relocs.  */
6992           return TRUE;
6993         }
6994     }
6995   else
6996     h->plt.plist = NULL;
6997
6998   /* If this is a weak symbol, and there is a real definition, the
6999      processor independent code will have arranged for us to see the
7000      real definition first, and we can just use the same value.  */
7001   if (h->u.weakdef != NULL)
7002     {
7003       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7004                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7005       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7006       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7007       if (ELIMINATE_COPY_RELOCS)
7008         h->non_got_ref = h->u.weakdef->non_got_ref;
7009       return TRUE;
7010     }
7011
7012   /* If we are creating a shared library, we must presume that the
7013      only references to the symbol are via the global offset table.
7014      For such cases we need not do anything here; the relocations will
7015      be handled correctly by relocate_section.  */
7016   if (info->shared)
7017     return TRUE;
7018
7019   /* If there are no references to this symbol that do not use the
7020      GOT, we don't need to generate a copy reloc.  */
7021   if (!h->non_got_ref)
7022     return TRUE;
7023
7024   /* Don't generate a copy reloc for symbols defined in the executable.  */
7025   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7026     return TRUE;
7027
7028   /* If we didn't find any dynamic relocs in read-only sections, then
7029      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7030   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7031     {
7032       h->non_got_ref = 0;
7033       return TRUE;
7034     }
7035
7036   if (h->plt.plist != NULL)
7037     {
7038       /* We should never get here, but unfortunately there are versions
7039          of gcc out there that improperly (for this ABI) put initialized
7040          function pointers, vtable refs and suchlike in read-only
7041          sections.  Allow them to proceed, but warn that this might
7042          break at runtime.  */
7043       info->callbacks->einfo
7044         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7045            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7046          h->root.root.string);
7047     }
7048
7049   /* This is a reference to a symbol defined by a dynamic object which
7050      is not a function.  */
7051
7052   /* We must allocate the symbol in our .dynbss section, which will
7053      become part of the .bss section of the executable.  There will be
7054      an entry for this symbol in the .dynsym section.  The dynamic
7055      object will contain position independent code, so all references
7056      from the dynamic object to this symbol will go through the global
7057      offset table.  The dynamic linker will use the .dynsym entry to
7058      determine the address it must put in the global offset table, so
7059      both the dynamic object and the regular object will refer to the
7060      same memory location for the variable.  */
7061
7062   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7063      to copy the initial value out of the dynamic object and into the
7064      runtime process image.  We need to remember the offset into the
7065      .rela.bss section we are going to use.  */
7066   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7067     {
7068       htab->relbss->size += sizeof (Elf64_External_Rela);
7069       h->needs_copy = 1;
7070     }
7071
7072   s = htab->dynbss;
7073
7074   return _bfd_elf_adjust_dynamic_copy (h, s);
7075 }
7076
7077 /* If given a function descriptor symbol, hide both the function code
7078    sym and the descriptor.  */
7079 static void
7080 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7081                        struct elf_link_hash_entry *h,
7082                        bfd_boolean force_local)
7083 {
7084   struct ppc_link_hash_entry *eh;
7085   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7086
7087   eh = (struct ppc_link_hash_entry *) h;
7088   if (eh->is_func_descriptor)
7089     {
7090       struct ppc_link_hash_entry *fh = eh->oh;
7091
7092       if (fh == NULL)
7093         {
7094           const char *p, *q;
7095           struct ppc_link_hash_table *htab;
7096           char save;
7097
7098           /* We aren't supposed to use alloca in BFD because on
7099              systems which do not have alloca the version in libiberty
7100              calls xmalloc, which might cause the program to crash
7101              when it runs out of memory.  This function doesn't have a
7102              return status, so there's no way to gracefully return an
7103              error.  So cheat.  We know that string[-1] can be safely
7104              accessed;  It's either a string in an ELF string table,
7105              or allocated in an objalloc structure.  */
7106
7107           p = eh->elf.root.root.string - 1;
7108           save = *p;
7109           *(char *) p = '.';
7110           htab = ppc_hash_table (info);
7111           if (htab == NULL)
7112             return;
7113
7114           fh = (struct ppc_link_hash_entry *)
7115             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7116           *(char *) p = save;
7117
7118           /* Unfortunately, if it so happens that the string we were
7119              looking for was allocated immediately before this string,
7120              then we overwrote the string terminator.  That's the only
7121              reason the lookup should fail.  */
7122           if (fh == NULL)
7123             {
7124               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7125               while (q >= eh->elf.root.root.string && *q == *p)
7126                 --q, --p;
7127               if (q < eh->elf.root.root.string && *p == '.')
7128                 fh = (struct ppc_link_hash_entry *)
7129                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7130             }
7131           if (fh != NULL)
7132             {
7133               eh->oh = fh;
7134               fh->oh = eh;
7135             }
7136         }
7137       if (fh != NULL)
7138         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7139     }
7140 }
7141
7142 static bfd_boolean
7143 get_sym_h (struct elf_link_hash_entry **hp,
7144            Elf_Internal_Sym **symp,
7145            asection **symsecp,
7146            unsigned char **tls_maskp,
7147            Elf_Internal_Sym **locsymsp,
7148            unsigned long r_symndx,
7149            bfd *ibfd)
7150 {
7151   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7152
7153   if (r_symndx >= symtab_hdr->sh_info)
7154     {
7155       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7156       struct elf_link_hash_entry *h;
7157
7158       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7159       h = elf_follow_link (h);
7160
7161       if (hp != NULL)
7162         *hp = h;
7163
7164       if (symp != NULL)
7165         *symp = NULL;
7166
7167       if (symsecp != NULL)
7168         {
7169           asection *symsec = NULL;
7170           if (h->root.type == bfd_link_hash_defined
7171               || h->root.type == bfd_link_hash_defweak)
7172             symsec = h->root.u.def.section;
7173           *symsecp = symsec;
7174         }
7175
7176       if (tls_maskp != NULL)
7177         {
7178           struct ppc_link_hash_entry *eh;
7179
7180           eh = (struct ppc_link_hash_entry *) h;
7181           *tls_maskp = &eh->tls_mask;
7182         }
7183     }
7184   else
7185     {
7186       Elf_Internal_Sym *sym;
7187       Elf_Internal_Sym *locsyms = *locsymsp;
7188
7189       if (locsyms == NULL)
7190         {
7191           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7192           if (locsyms == NULL)
7193             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7194                                             symtab_hdr->sh_info,
7195                                             0, NULL, NULL, NULL);
7196           if (locsyms == NULL)
7197             return FALSE;
7198           *locsymsp = locsyms;
7199         }
7200       sym = locsyms + r_symndx;
7201
7202       if (hp != NULL)
7203         *hp = NULL;
7204
7205       if (symp != NULL)
7206         *symp = sym;
7207
7208       if (symsecp != NULL)
7209         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7210
7211       if (tls_maskp != NULL)
7212         {
7213           struct got_entry **lgot_ents;
7214           unsigned char *tls_mask;
7215
7216           tls_mask = NULL;
7217           lgot_ents = elf_local_got_ents (ibfd);
7218           if (lgot_ents != NULL)
7219             {
7220               struct plt_entry **local_plt = (struct plt_entry **)
7221                 (lgot_ents + symtab_hdr->sh_info);
7222               unsigned char *lgot_masks = (unsigned char *)
7223                 (local_plt + symtab_hdr->sh_info);
7224               tls_mask = &lgot_masks[r_symndx];
7225             }
7226           *tls_maskp = tls_mask;
7227         }
7228     }
7229   return TRUE;
7230 }
7231
7232 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7233    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7234    type suitable for optimization, and 1 otherwise.  */
7235
7236 static int
7237 get_tls_mask (unsigned char **tls_maskp,
7238               unsigned long *toc_symndx,
7239               bfd_vma *toc_addend,
7240               Elf_Internal_Sym **locsymsp,
7241               const Elf_Internal_Rela *rel,
7242               bfd *ibfd)
7243 {
7244   unsigned long r_symndx;
7245   int next_r;
7246   struct elf_link_hash_entry *h;
7247   Elf_Internal_Sym *sym;
7248   asection *sec;
7249   bfd_vma off;
7250
7251   r_symndx = ELF64_R_SYM (rel->r_info);
7252   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7253     return 0;
7254
7255   if ((*tls_maskp != NULL && **tls_maskp != 0)
7256       || sec == NULL
7257       || ppc64_elf_section_data (sec) == NULL
7258       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7259     return 1;
7260
7261   /* Look inside a TOC section too.  */
7262   if (h != NULL)
7263     {
7264       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7265       off = h->root.u.def.value;
7266     }
7267   else
7268     off = sym->st_value;
7269   off += rel->r_addend;
7270   BFD_ASSERT (off % 8 == 0);
7271   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7272   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7273   if (toc_symndx != NULL)
7274     *toc_symndx = r_symndx;
7275   if (toc_addend != NULL)
7276     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7277   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7278     return 0;
7279   if ((h == NULL || is_static_defined (h))
7280       && (next_r == -1 || next_r == -2))
7281     return 1 - next_r;
7282   return 1;
7283 }
7284
7285 /* Find (or create) an entry in the tocsave hash table.  */
7286
7287 static struct tocsave_entry *
7288 tocsave_find (struct ppc_link_hash_table *htab,
7289               enum insert_option insert,
7290               Elf_Internal_Sym **local_syms,
7291               const Elf_Internal_Rela *irela,
7292               bfd *ibfd)
7293 {
7294   unsigned long r_indx;
7295   struct elf_link_hash_entry *h;
7296   Elf_Internal_Sym *sym;
7297   struct tocsave_entry ent, *p;
7298   hashval_t hash;
7299   struct tocsave_entry **slot;
7300
7301   r_indx = ELF64_R_SYM (irela->r_info);
7302   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7303     return NULL;
7304   if (ent.sec == NULL || ent.sec->output_section == NULL)
7305     {
7306       (*_bfd_error_handler)
7307         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7308       return NULL;
7309     }
7310
7311   if (h != NULL)
7312     ent.offset = h->root.u.def.value;
7313   else
7314     ent.offset = sym->st_value;
7315   ent.offset += irela->r_addend;
7316
7317   hash = tocsave_htab_hash (&ent);
7318   slot = ((struct tocsave_entry **)
7319           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7320   if (slot == NULL)
7321     return NULL;
7322
7323   if (*slot == NULL)
7324     {
7325       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7326       if (p == NULL)
7327         return NULL;
7328       *p = ent;
7329       *slot = p;
7330     }
7331   return *slot;
7332 }
7333
7334 /* Adjust all global syms defined in opd sections.  In gcc generated
7335    code for the old ABI, these will already have been done.  */
7336
7337 static bfd_boolean
7338 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7339 {
7340   struct ppc_link_hash_entry *eh;
7341   asection *sym_sec;
7342   struct _opd_sec_data *opd;
7343
7344   if (h->root.type == bfd_link_hash_indirect)
7345     return TRUE;
7346
7347   if (h->root.type != bfd_link_hash_defined
7348       && h->root.type != bfd_link_hash_defweak)
7349     return TRUE;
7350
7351   eh = (struct ppc_link_hash_entry *) h;
7352   if (eh->adjust_done)
7353     return TRUE;
7354
7355   sym_sec = eh->elf.root.u.def.section;
7356   opd = get_opd_info (sym_sec);
7357   if (opd != NULL && opd->adjust != NULL)
7358     {
7359       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7360       if (adjust == -1)
7361         {
7362           /* This entry has been deleted.  */
7363           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7364           if (dsec == NULL)
7365             {
7366               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7367                 if (discarded_section (dsec))
7368                   {
7369                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7370                     break;
7371                   }
7372             }
7373           eh->elf.root.u.def.value = 0;
7374           eh->elf.root.u.def.section = dsec;
7375         }
7376       else
7377         eh->elf.root.u.def.value += adjust;
7378       eh->adjust_done = 1;
7379     }
7380   return TRUE;
7381 }
7382
7383 /* Handles decrementing dynamic reloc counts for the reloc specified by
7384    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7385    have already been determined.  */
7386
7387 static bfd_boolean
7388 dec_dynrel_count (bfd_vma r_info,
7389                   asection *sec,
7390                   struct bfd_link_info *info,
7391                   Elf_Internal_Sym **local_syms,
7392                   struct elf_link_hash_entry *h,
7393                   Elf_Internal_Sym *sym)
7394 {
7395   enum elf_ppc64_reloc_type r_type;
7396   asection *sym_sec = NULL;
7397
7398   /* Can this reloc be dynamic?  This switch, and later tests here
7399      should be kept in sync with the code in check_relocs.  */
7400   r_type = ELF64_R_TYPE (r_info);
7401   switch (r_type)
7402     {
7403     default:
7404       return TRUE;
7405
7406     case R_PPC64_TPREL16:
7407     case R_PPC64_TPREL16_LO:
7408     case R_PPC64_TPREL16_HI:
7409     case R_PPC64_TPREL16_HA:
7410     case R_PPC64_TPREL16_DS:
7411     case R_PPC64_TPREL16_LO_DS:
7412     case R_PPC64_TPREL16_HIGH:
7413     case R_PPC64_TPREL16_HIGHA:
7414     case R_PPC64_TPREL16_HIGHER:
7415     case R_PPC64_TPREL16_HIGHERA:
7416     case R_PPC64_TPREL16_HIGHEST:
7417     case R_PPC64_TPREL16_HIGHESTA:
7418       if (!info->shared)
7419         return TRUE;
7420
7421     case R_PPC64_TPREL64:
7422     case R_PPC64_DTPMOD64:
7423     case R_PPC64_DTPREL64:
7424     case R_PPC64_ADDR64:
7425     case R_PPC64_REL30:
7426     case R_PPC64_REL32:
7427     case R_PPC64_REL64:
7428     case R_PPC64_ADDR14:
7429     case R_PPC64_ADDR14_BRNTAKEN:
7430     case R_PPC64_ADDR14_BRTAKEN:
7431     case R_PPC64_ADDR16:
7432     case R_PPC64_ADDR16_DS:
7433     case R_PPC64_ADDR16_HA:
7434     case R_PPC64_ADDR16_HI:
7435     case R_PPC64_ADDR16_HIGH:
7436     case R_PPC64_ADDR16_HIGHA:
7437     case R_PPC64_ADDR16_HIGHER:
7438     case R_PPC64_ADDR16_HIGHERA:
7439     case R_PPC64_ADDR16_HIGHEST:
7440     case R_PPC64_ADDR16_HIGHESTA:
7441     case R_PPC64_ADDR16_LO:
7442     case R_PPC64_ADDR16_LO_DS:
7443     case R_PPC64_ADDR24:
7444     case R_PPC64_ADDR32:
7445     case R_PPC64_UADDR16:
7446     case R_PPC64_UADDR32:
7447     case R_PPC64_UADDR64:
7448     case R_PPC64_TOC:
7449       break;
7450     }
7451
7452   if (local_syms != NULL)
7453     {
7454       unsigned long r_symndx;
7455       bfd *ibfd = sec->owner;
7456
7457       r_symndx = ELF64_R_SYM (r_info);
7458       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7459         return FALSE;
7460     }
7461
7462   if ((info->shared
7463        && (must_be_dyn_reloc (info, r_type)
7464            || (h != NULL
7465                && (!SYMBOLIC_BIND (info, h)
7466                    || h->root.type == bfd_link_hash_defweak
7467                    || !h->def_regular))))
7468       || (ELIMINATE_COPY_RELOCS
7469           && !info->shared
7470           && h != NULL
7471           && (h->root.type == bfd_link_hash_defweak
7472               || !h->def_regular)))
7473     ;
7474   else
7475     return TRUE;
7476
7477   if (h != NULL)
7478     {
7479       struct elf_dyn_relocs *p;
7480       struct elf_dyn_relocs **pp;
7481       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7482
7483       /* elf_gc_sweep may have already removed all dyn relocs associated
7484          with local syms for a given section.  Also, symbol flags are
7485          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7486          report a dynreloc miscount.  */
7487       if (*pp == NULL && info->gc_sections)
7488         return TRUE;
7489
7490       while ((p = *pp) != NULL)
7491         {
7492           if (p->sec == sec)
7493             {
7494               if (!must_be_dyn_reloc (info, r_type))
7495                 p->pc_count -= 1;
7496               p->count -= 1;
7497               if (p->count == 0)
7498                 *pp = p->next;
7499               return TRUE;
7500             }
7501           pp = &p->next;
7502         }
7503     }
7504   else
7505     {
7506       struct ppc_dyn_relocs *p;
7507       struct ppc_dyn_relocs **pp;
7508       void *vpp;
7509       bfd_boolean is_ifunc;
7510
7511       if (local_syms == NULL)
7512         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7513       if (sym_sec == NULL)
7514         sym_sec = sec;
7515
7516       vpp = &elf_section_data (sym_sec)->local_dynrel;
7517       pp = (struct ppc_dyn_relocs **) vpp;
7518
7519       if (*pp == NULL && info->gc_sections)
7520         return TRUE;
7521
7522       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7523       while ((p = *pp) != NULL)
7524         {
7525           if (p->sec == sec && p->ifunc == is_ifunc)
7526             {
7527               p->count -= 1;
7528               if (p->count == 0)
7529                 *pp = p->next;
7530               return TRUE;
7531             }
7532           pp = &p->next;
7533         }
7534     }
7535
7536   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7537                           sec->owner, sec);
7538   bfd_set_error (bfd_error_bad_value);
7539   return FALSE;
7540 }
7541
7542 /* Remove unused Official Procedure Descriptor entries.  Currently we
7543    only remove those associated with functions in discarded link-once
7544    sections, or weakly defined functions that have been overridden.  It
7545    would be possible to remove many more entries for statically linked
7546    applications.  */
7547
7548 bfd_boolean
7549 ppc64_elf_edit_opd (struct bfd_link_info *info)
7550 {
7551   bfd *ibfd;
7552   bfd_boolean some_edited = FALSE;
7553   asection *need_pad = NULL;
7554   struct ppc_link_hash_table *htab;
7555
7556   htab = ppc_hash_table (info);
7557   if (htab == NULL)
7558     return FALSE;
7559
7560   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7561     {
7562       asection *sec;
7563       Elf_Internal_Rela *relstart, *rel, *relend;
7564       Elf_Internal_Shdr *symtab_hdr;
7565       Elf_Internal_Sym *local_syms;
7566       bfd_vma offset;
7567       struct _opd_sec_data *opd;
7568       bfd_boolean need_edit, add_aux_fields;
7569       bfd_size_type cnt_16b = 0;
7570
7571       if (!is_ppc64_elf (ibfd))
7572         continue;
7573
7574       sec = bfd_get_section_by_name (ibfd, ".opd");
7575       if (sec == NULL || sec->size == 0)
7576         continue;
7577
7578       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7579         continue;
7580
7581       if (sec->output_section == bfd_abs_section_ptr)
7582         continue;
7583
7584       /* Look through the section relocs.  */
7585       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7586         continue;
7587
7588       local_syms = NULL;
7589       symtab_hdr = &elf_symtab_hdr (ibfd);
7590
7591       /* Read the relocations.  */
7592       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7593                                             info->keep_memory);
7594       if (relstart == NULL)
7595         return FALSE;
7596
7597       /* First run through the relocs to check they are sane, and to
7598          determine whether we need to edit this opd section.  */
7599       need_edit = FALSE;
7600       need_pad = sec;
7601       offset = 0;
7602       relend = relstart + sec->reloc_count;
7603       for (rel = relstart; rel < relend; )
7604         {
7605           enum elf_ppc64_reloc_type r_type;
7606           unsigned long r_symndx;
7607           asection *sym_sec;
7608           struct elf_link_hash_entry *h;
7609           Elf_Internal_Sym *sym;
7610
7611           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7612              only interested in the reloc pointing to a function entry
7613              point.  */
7614           if (rel->r_offset != offset
7615               || rel + 1 >= relend
7616               || (rel + 1)->r_offset != offset + 8)
7617             {
7618               /* If someone messes with .opd alignment then after a
7619                  "ld -r" we might have padding in the middle of .opd.
7620                  Also, there's nothing to prevent someone putting
7621                  something silly in .opd with the assembler.  No .opd
7622                  optimization for them!  */
7623             broken_opd:
7624               (*_bfd_error_handler)
7625                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7626               need_edit = FALSE;
7627               break;
7628             }
7629
7630           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7631               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7632             {
7633               (*_bfd_error_handler)
7634                 (_("%B: unexpected reloc type %u in .opd section"),
7635                  ibfd, r_type);
7636               need_edit = FALSE;
7637               break;
7638             }
7639
7640           r_symndx = ELF64_R_SYM (rel->r_info);
7641           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7642                           r_symndx, ibfd))
7643             goto error_ret;
7644
7645           if (sym_sec == NULL || sym_sec->owner == NULL)
7646             {
7647               const char *sym_name;
7648               if (h != NULL)
7649                 sym_name = h->root.root.string;
7650               else
7651                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7652                                              sym_sec);
7653
7654               (*_bfd_error_handler)
7655                 (_("%B: undefined sym `%s' in .opd section"),
7656                  ibfd, sym_name);
7657               need_edit = FALSE;
7658               break;
7659             }
7660
7661           /* opd entries are always for functions defined in the
7662              current input bfd.  If the symbol isn't defined in the
7663              input bfd, then we won't be using the function in this
7664              bfd;  It must be defined in a linkonce section in another
7665              bfd, or is weak.  It's also possible that we are
7666              discarding the function due to a linker script /DISCARD/,
7667              which we test for via the output_section.  */
7668           if (sym_sec->owner != ibfd
7669               || sym_sec->output_section == bfd_abs_section_ptr)
7670             need_edit = TRUE;
7671
7672           rel += 2;
7673           if (rel == relend
7674               || (rel + 1 == relend && rel->r_offset == offset + 16))
7675             {
7676               if (sec->size == offset + 24)
7677                 {
7678                   need_pad = NULL;
7679                   break;
7680                 }
7681               if (rel == relend && sec->size == offset + 16)
7682                 {
7683                   cnt_16b++;
7684                   break;
7685                 }
7686               goto broken_opd;
7687             }
7688
7689           if (rel->r_offset == offset + 24)
7690             offset += 24;
7691           else if (rel->r_offset != offset + 16)
7692             goto broken_opd;
7693           else if (rel + 1 < relend
7694                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7695                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7696             {
7697               offset += 16;
7698               cnt_16b++;
7699             }
7700           else if (rel + 2 < relend
7701                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7702                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7703             {
7704               offset += 24;
7705               rel += 1;
7706             }
7707           else
7708             goto broken_opd;
7709         }
7710
7711       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7712
7713       if (need_edit || add_aux_fields)
7714         {
7715           Elf_Internal_Rela *write_rel;
7716           Elf_Internal_Shdr *rel_hdr;
7717           bfd_byte *rptr, *wptr;
7718           bfd_byte *new_contents;
7719           bfd_boolean skip;
7720           long opd_ent_size;
7721           bfd_size_type amt;
7722
7723           new_contents = NULL;
7724           amt = sec->size * sizeof (long) / 8;
7725           opd = &ppc64_elf_section_data (sec)->u.opd;
7726           opd->adjust = bfd_zalloc (sec->owner, amt);
7727           if (opd->adjust == NULL)
7728             return FALSE;
7729           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7730
7731           /* This seems a waste of time as input .opd sections are all
7732              zeros as generated by gcc, but I suppose there's no reason
7733              this will always be so.  We might start putting something in
7734              the third word of .opd entries.  */
7735           if ((sec->flags & SEC_IN_MEMORY) == 0)
7736             {
7737               bfd_byte *loc;
7738               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7739                 {
7740                   if (loc != NULL)
7741                     free (loc);
7742                 error_ret:
7743                   if (local_syms != NULL
7744                       && symtab_hdr->contents != (unsigned char *) local_syms)
7745                     free (local_syms);
7746                   if (elf_section_data (sec)->relocs != relstart)
7747                     free (relstart);
7748                   return FALSE;
7749                 }
7750               sec->contents = loc;
7751               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7752             }
7753
7754           elf_section_data (sec)->relocs = relstart;
7755
7756           new_contents = sec->contents;
7757           if (add_aux_fields)
7758             {
7759               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7760               if (new_contents == NULL)
7761                 return FALSE;
7762               need_pad = FALSE;
7763             }
7764           wptr = new_contents;
7765           rptr = sec->contents;
7766
7767           write_rel = relstart;
7768           skip = FALSE;
7769           offset = 0;
7770           opd_ent_size = 0;
7771           for (rel = relstart; rel < relend; rel++)
7772             {
7773               unsigned long r_symndx;
7774               asection *sym_sec;
7775               struct elf_link_hash_entry *h;
7776               Elf_Internal_Sym *sym;
7777
7778               r_symndx = ELF64_R_SYM (rel->r_info);
7779               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7780                               r_symndx, ibfd))
7781                 goto error_ret;
7782
7783               if (rel->r_offset == offset)
7784                 {
7785                   struct ppc_link_hash_entry *fdh = NULL;
7786
7787                   /* See if the .opd entry is full 24 byte or
7788                      16 byte (with fd_aux entry overlapped with next
7789                      fd_func).  */
7790                   opd_ent_size = 24;
7791                   if ((rel + 2 == relend && sec->size == offset + 16)
7792                       || (rel + 3 < relend
7793                           && rel[2].r_offset == offset + 16
7794                           && rel[3].r_offset == offset + 24
7795                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7796                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7797                     opd_ent_size = 16;
7798
7799                   if (h != NULL
7800                       && h->root.root.string[0] == '.')
7801                     {
7802                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7803                       if (fdh != NULL
7804                           && fdh->elf.root.type != bfd_link_hash_defined
7805                           && fdh->elf.root.type != bfd_link_hash_defweak)
7806                         fdh = NULL;
7807                     }
7808
7809                   skip = (sym_sec->owner != ibfd
7810                           || sym_sec->output_section == bfd_abs_section_ptr);
7811                   if (skip)
7812                     {
7813                       if (fdh != NULL && sym_sec->owner == ibfd)
7814                         {
7815                           /* Arrange for the function descriptor sym
7816                              to be dropped.  */
7817                           fdh->elf.root.u.def.value = 0;
7818                           fdh->elf.root.u.def.section = sym_sec;
7819                         }
7820                       opd->adjust[rel->r_offset / 8] = -1;
7821                     }
7822                   else
7823                     {
7824                       /* We'll be keeping this opd entry.  */
7825
7826                       if (fdh != NULL)
7827                         {
7828                           /* Redefine the function descriptor symbol to
7829                              this location in the opd section.  It is
7830                              necessary to update the value here rather
7831                              than using an array of adjustments as we do
7832                              for local symbols, because various places
7833                              in the generic ELF code use the value
7834                              stored in u.def.value.  */
7835                           fdh->elf.root.u.def.value = wptr - new_contents;
7836                           fdh->adjust_done = 1;
7837                         }
7838
7839                       /* Local syms are a bit tricky.  We could
7840                          tweak them as they can be cached, but
7841                          we'd need to look through the local syms
7842                          for the function descriptor sym which we
7843                          don't have at the moment.  So keep an
7844                          array of adjustments.  */
7845                       opd->adjust[rel->r_offset / 8]
7846                         = (wptr - new_contents) - (rptr - sec->contents);
7847
7848                       if (wptr != rptr)
7849                         memcpy (wptr, rptr, opd_ent_size);
7850                       wptr += opd_ent_size;
7851                       if (add_aux_fields && opd_ent_size == 16)
7852                         {
7853                           memset (wptr, '\0', 8);
7854                           wptr += 8;
7855                         }
7856                     }
7857                   rptr += opd_ent_size;
7858                   offset += opd_ent_size;
7859                 }
7860
7861               if (skip)
7862                 {
7863                   if (!NO_OPD_RELOCS
7864                       && !info->relocatable
7865                       && !dec_dynrel_count (rel->r_info, sec, info,
7866                                             NULL, h, sym))
7867                     goto error_ret;
7868                 }
7869               else
7870                 {
7871                   /* We need to adjust any reloc offsets to point to the
7872                      new opd entries.  While we're at it, we may as well
7873                      remove redundant relocs.  */
7874                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7875                   if (write_rel != rel)
7876                     memcpy (write_rel, rel, sizeof (*rel));
7877                   ++write_rel;
7878                 }
7879             }
7880
7881           sec->size = wptr - new_contents;
7882           sec->reloc_count = write_rel - relstart;
7883           if (add_aux_fields)
7884             {
7885               free (sec->contents);
7886               sec->contents = new_contents;
7887             }
7888
7889           /* Fudge the header size too, as this is used later in
7890              elf_bfd_final_link if we are emitting relocs.  */
7891           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7892           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7893           some_edited = TRUE;
7894         }
7895       else if (elf_section_data (sec)->relocs != relstart)
7896         free (relstart);
7897
7898       if (local_syms != NULL
7899           && symtab_hdr->contents != (unsigned char *) local_syms)
7900         {
7901           if (!info->keep_memory)
7902             free (local_syms);
7903           else
7904             symtab_hdr->contents = (unsigned char *) local_syms;
7905         }
7906     }
7907
7908   if (some_edited)
7909     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7910
7911   /* If we are doing a final link and the last .opd entry is just 16 byte
7912      long, add a 8 byte padding after it.  */
7913   if (need_pad != NULL && !info->relocatable)
7914     {
7915       bfd_byte *p;
7916
7917       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7918         {
7919           BFD_ASSERT (need_pad->size > 0);
7920
7921           p = bfd_malloc (need_pad->size + 8);
7922           if (p == NULL)
7923             return FALSE;
7924
7925           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7926                                           p, 0, need_pad->size))
7927             return FALSE;
7928
7929           need_pad->contents = p;
7930           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7931         }
7932       else
7933         {
7934           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7935           if (p == NULL)
7936             return FALSE;
7937
7938           need_pad->contents = p;
7939         }
7940
7941       memset (need_pad->contents + need_pad->size, 0, 8);
7942       need_pad->size += 8;
7943     }
7944
7945   return TRUE;
7946 }
7947
7948 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7949
7950 asection *
7951 ppc64_elf_tls_setup (struct bfd_link_info *info)
7952 {
7953   struct ppc_link_hash_table *htab;
7954
7955   htab = ppc_hash_table (info);
7956   if (htab == NULL)
7957     return NULL;
7958
7959   if (abiversion (info->output_bfd) == 1)
7960     htab->opd_abi = 1;
7961
7962   if (htab->params->no_multi_toc)
7963     htab->do_multi_toc = 0;
7964   else if (!htab->do_multi_toc)
7965     htab->params->no_multi_toc = 1;
7966
7967   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7968                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7969                                               FALSE, FALSE, TRUE));
7970   /* Move dynamic linking info to the function descriptor sym.  */
7971   if (htab->tls_get_addr != NULL)
7972     func_desc_adjust (&htab->tls_get_addr->elf, info);
7973   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7974                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7975                                                  FALSE, FALSE, TRUE));
7976   if (!htab->params->no_tls_get_addr_opt)
7977     {
7978       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7979
7980       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7981                                   FALSE, FALSE, TRUE);
7982       if (opt != NULL)
7983         func_desc_adjust (opt, info);
7984       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7985                                      FALSE, FALSE, TRUE);
7986       if (opt_fd != NULL
7987           && (opt_fd->root.type == bfd_link_hash_defined
7988               || opt_fd->root.type == bfd_link_hash_defweak))
7989         {
7990           /* If glibc supports an optimized __tls_get_addr call stub,
7991              signalled by the presence of __tls_get_addr_opt, and we'll
7992              be calling __tls_get_addr via a plt call stub, then
7993              make __tls_get_addr point to __tls_get_addr_opt.  */
7994           tga_fd = &htab->tls_get_addr_fd->elf;
7995           if (htab->elf.dynamic_sections_created
7996               && tga_fd != NULL
7997               && (tga_fd->type == STT_FUNC
7998                   || tga_fd->needs_plt)
7999               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8000                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8001                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8002             {
8003               struct plt_entry *ent;
8004
8005               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8006                 if (ent->plt.refcount > 0)
8007                   break;
8008               if (ent != NULL)
8009                 {
8010                   tga_fd->root.type = bfd_link_hash_indirect;
8011                   tga_fd->root.u.i.link = &opt_fd->root;
8012                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8013                   if (opt_fd->dynindx != -1)
8014                     {
8015                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8016                       opt_fd->dynindx = -1;
8017                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8018                                               opt_fd->dynstr_index);
8019                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8020                         return NULL;
8021                     }
8022                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8023                   tga = &htab->tls_get_addr->elf;
8024                   if (opt != NULL && tga != NULL)
8025                     {
8026                       tga->root.type = bfd_link_hash_indirect;
8027                       tga->root.u.i.link = &opt->root;
8028                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8029                       _bfd_elf_link_hash_hide_symbol (info, opt,
8030                                                       tga->forced_local);
8031                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8032                     }
8033                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8034                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8035                   if (htab->tls_get_addr != NULL)
8036                     {
8037                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8038                       htab->tls_get_addr->is_func = 1;
8039                     }
8040                 }
8041             }
8042         }
8043       else
8044         htab->params->no_tls_get_addr_opt = TRUE;
8045     }
8046   return _bfd_elf_tls_setup (info->output_bfd, info);
8047 }
8048
8049 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8050    HASH1 or HASH2.  */
8051
8052 static bfd_boolean
8053 branch_reloc_hash_match (const bfd *ibfd,
8054                          const Elf_Internal_Rela *rel,
8055                          const struct ppc_link_hash_entry *hash1,
8056                          const struct ppc_link_hash_entry *hash2)
8057 {
8058   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8059   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8060   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8061
8062   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8063     {
8064       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8065       struct elf_link_hash_entry *h;
8066
8067       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8068       h = elf_follow_link (h);
8069       if (h == &hash1->elf || h == &hash2->elf)
8070         return TRUE;
8071     }
8072   return FALSE;
8073 }
8074
8075 /* Run through all the TLS relocs looking for optimization
8076    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8077    a preliminary section layout so that we know the TLS segment
8078    offsets.  We can't optimize earlier because some optimizations need
8079    to know the tp offset, and we need to optimize before allocating
8080    dynamic relocations.  */
8081
8082 bfd_boolean
8083 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8084 {
8085   bfd *ibfd;
8086   asection *sec;
8087   struct ppc_link_hash_table *htab;
8088   unsigned char *toc_ref;
8089   int pass;
8090
8091   if (info->relocatable || !info->executable)
8092     return TRUE;
8093
8094   htab = ppc_hash_table (info);
8095   if (htab == NULL)
8096     return FALSE;
8097
8098   /* Make two passes over the relocs.  On the first pass, mark toc
8099      entries involved with tls relocs, and check that tls relocs
8100      involved in setting up a tls_get_addr call are indeed followed by
8101      such a call.  If they are not, we can't do any tls optimization.
8102      On the second pass twiddle tls_mask flags to notify
8103      relocate_section that optimization can be done, and adjust got
8104      and plt refcounts.  */
8105   toc_ref = NULL;
8106   for (pass = 0; pass < 2; ++pass)
8107     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8108       {
8109         Elf_Internal_Sym *locsyms = NULL;
8110         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8111
8112         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8113           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8114             {
8115               Elf_Internal_Rela *relstart, *rel, *relend;
8116               bfd_boolean found_tls_get_addr_arg = 0;
8117
8118               /* Read the relocations.  */
8119               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8120                                                     info->keep_memory);
8121               if (relstart == NULL)
8122                 {
8123                   free (toc_ref);
8124                   return FALSE;
8125                 }
8126
8127               relend = relstart + sec->reloc_count;
8128               for (rel = relstart; rel < relend; rel++)
8129                 {
8130                   enum elf_ppc64_reloc_type r_type;
8131                   unsigned long r_symndx;
8132                   struct elf_link_hash_entry *h;
8133                   Elf_Internal_Sym *sym;
8134                   asection *sym_sec;
8135                   unsigned char *tls_mask;
8136                   unsigned char tls_set, tls_clear, tls_type = 0;
8137                   bfd_vma value;
8138                   bfd_boolean ok_tprel, is_local;
8139                   long toc_ref_index = 0;
8140                   int expecting_tls_get_addr = 0;
8141                   bfd_boolean ret = FALSE;
8142
8143                   r_symndx = ELF64_R_SYM (rel->r_info);
8144                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8145                                   r_symndx, ibfd))
8146                     {
8147                     err_free_rel:
8148                       if (elf_section_data (sec)->relocs != relstart)
8149                         free (relstart);
8150                       if (toc_ref != NULL)
8151                         free (toc_ref);
8152                       if (locsyms != NULL
8153                           && (elf_symtab_hdr (ibfd).contents
8154                               != (unsigned char *) locsyms))
8155                         free (locsyms);
8156                       return ret;
8157                     }
8158
8159                   if (h != NULL)
8160                     {
8161                       if (h->root.type == bfd_link_hash_defined
8162                           || h->root.type == bfd_link_hash_defweak)
8163                         value = h->root.u.def.value;
8164                       else if (h->root.type == bfd_link_hash_undefweak)
8165                         value = 0;
8166                       else
8167                         {
8168                           found_tls_get_addr_arg = 0;
8169                           continue;
8170                         }
8171                     }
8172                   else
8173                     /* Symbols referenced by TLS relocs must be of type
8174                        STT_TLS.  So no need for .opd local sym adjust.  */
8175                     value = sym->st_value;
8176
8177                   ok_tprel = FALSE;
8178                   is_local = FALSE;
8179                   if (h == NULL
8180                       || !h->def_dynamic)
8181                     {
8182                       is_local = TRUE;
8183                       if (h != NULL
8184                           && h->root.type == bfd_link_hash_undefweak)
8185                         ok_tprel = TRUE;
8186                       else
8187                         {
8188                           value += sym_sec->output_offset;
8189                           value += sym_sec->output_section->vma;
8190                           value -= htab->elf.tls_sec->vma;
8191                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8192                                       < (bfd_vma) 1 << 32);
8193                         }
8194                     }
8195
8196                   r_type = ELF64_R_TYPE (rel->r_info);
8197                   /* If this section has old-style __tls_get_addr calls
8198                      without marker relocs, then check that each
8199                      __tls_get_addr call reloc is preceded by a reloc
8200                      that conceivably belongs to the __tls_get_addr arg
8201                      setup insn.  If we don't find matching arg setup
8202                      relocs, don't do any tls optimization.  */
8203                   if (pass == 0
8204                       && sec->has_tls_get_addr_call
8205                       && h != NULL
8206                       && (h == &htab->tls_get_addr->elf
8207                           || h == &htab->tls_get_addr_fd->elf)
8208                       && !found_tls_get_addr_arg
8209                       && is_branch_reloc (r_type))
8210                     {
8211                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8212                                                 "TLS optimization disabled\n"),
8213                                               ibfd, sec, rel->r_offset);
8214                       ret = TRUE;
8215                       goto err_free_rel;
8216                     }
8217
8218                   found_tls_get_addr_arg = 0;
8219                   switch (r_type)
8220                     {
8221                     case R_PPC64_GOT_TLSLD16:
8222                     case R_PPC64_GOT_TLSLD16_LO:
8223                       expecting_tls_get_addr = 1;
8224                       found_tls_get_addr_arg = 1;
8225                       /* Fall thru */
8226
8227                     case R_PPC64_GOT_TLSLD16_HI:
8228                     case R_PPC64_GOT_TLSLD16_HA:
8229                       /* These relocs should never be against a symbol
8230                          defined in a shared lib.  Leave them alone if
8231                          that turns out to be the case.  */
8232                       if (!is_local)
8233                         continue;
8234
8235                       /* LD -> LE */
8236                       tls_set = 0;
8237                       tls_clear = TLS_LD;
8238                       tls_type = TLS_TLS | TLS_LD;
8239                       break;
8240
8241                     case R_PPC64_GOT_TLSGD16:
8242                     case R_PPC64_GOT_TLSGD16_LO:
8243                       expecting_tls_get_addr = 1;
8244                       found_tls_get_addr_arg = 1;
8245                       /* Fall thru */
8246
8247                     case R_PPC64_GOT_TLSGD16_HI:
8248                     case R_PPC64_GOT_TLSGD16_HA:
8249                       if (ok_tprel)
8250                         /* GD -> LE */
8251                         tls_set = 0;
8252                       else
8253                         /* GD -> IE */
8254                         tls_set = TLS_TLS | TLS_TPRELGD;
8255                       tls_clear = TLS_GD;
8256                       tls_type = TLS_TLS | TLS_GD;
8257                       break;
8258
8259                     case R_PPC64_GOT_TPREL16_DS:
8260                     case R_PPC64_GOT_TPREL16_LO_DS:
8261                     case R_PPC64_GOT_TPREL16_HI:
8262                     case R_PPC64_GOT_TPREL16_HA:
8263                       if (ok_tprel)
8264                         {
8265                           /* IE -> LE */
8266                           tls_set = 0;
8267                           tls_clear = TLS_TPREL;
8268                           tls_type = TLS_TLS | TLS_TPREL;
8269                           break;
8270                         }
8271                       continue;
8272
8273                     case R_PPC64_TLSGD:
8274                     case R_PPC64_TLSLD:
8275                       found_tls_get_addr_arg = 1;
8276                       /* Fall thru */
8277
8278                     case R_PPC64_TLS:
8279                     case R_PPC64_TOC16:
8280                     case R_PPC64_TOC16_LO:
8281                       if (sym_sec == NULL || sym_sec != toc)
8282                         continue;
8283
8284                       /* Mark this toc entry as referenced by a TLS
8285                          code sequence.  We can do that now in the
8286                          case of R_PPC64_TLS, and after checking for
8287                          tls_get_addr for the TOC16 relocs.  */
8288                       if (toc_ref == NULL)
8289                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8290                       if (toc_ref == NULL)
8291                         goto err_free_rel;
8292
8293                       if (h != NULL)
8294                         value = h->root.u.def.value;
8295                       else
8296                         value = sym->st_value;
8297                       value += rel->r_addend;
8298                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8299                       toc_ref_index = (value + toc->output_offset) / 8;
8300                       if (r_type == R_PPC64_TLS
8301                           || r_type == R_PPC64_TLSGD
8302                           || r_type == R_PPC64_TLSLD)
8303                         {
8304                           toc_ref[toc_ref_index] = 1;
8305                           continue;
8306                         }
8307
8308                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8309                         continue;
8310
8311                       tls_set = 0;
8312                       tls_clear = 0;
8313                       expecting_tls_get_addr = 2;
8314                       break;
8315
8316                     case R_PPC64_TPREL64:
8317                       if (pass == 0
8318                           || sec != toc
8319                           || toc_ref == NULL
8320                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8321                         continue;
8322                       if (ok_tprel)
8323                         {
8324                           /* IE -> LE */
8325                           tls_set = TLS_EXPLICIT;
8326                           tls_clear = TLS_TPREL;
8327                           break;
8328                         }
8329                       continue;
8330
8331                     case R_PPC64_DTPMOD64:
8332                       if (pass == 0
8333                           || sec != toc
8334                           || toc_ref == NULL
8335                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8336                         continue;
8337                       if (rel + 1 < relend
8338                           && (rel[1].r_info
8339                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8340                           && rel[1].r_offset == rel->r_offset + 8)
8341                         {
8342                           if (ok_tprel)
8343                             /* GD -> LE */
8344                             tls_set = TLS_EXPLICIT | TLS_GD;
8345                           else
8346                             /* GD -> IE */
8347                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8348                           tls_clear = TLS_GD;
8349                         }
8350                       else
8351                         {
8352                           if (!is_local)
8353                             continue;
8354
8355                           /* LD -> LE */
8356                           tls_set = TLS_EXPLICIT;
8357                           tls_clear = TLS_LD;
8358                         }
8359                       break;
8360
8361                     default:
8362                       continue;
8363                     }
8364
8365                   if (pass == 0)
8366                     {
8367                       if (!expecting_tls_get_addr
8368                           || !sec->has_tls_get_addr_call)
8369                         continue;
8370
8371                       if (rel + 1 < relend
8372                           && branch_reloc_hash_match (ibfd, rel + 1,
8373                                                       htab->tls_get_addr,
8374                                                       htab->tls_get_addr_fd))
8375                         {
8376                           if (expecting_tls_get_addr == 2)
8377                             {
8378                               /* Check for toc tls entries.  */
8379                               unsigned char *toc_tls;
8380                               int retval;
8381
8382                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8383                                                      &locsyms,
8384                                                      rel, ibfd);
8385                               if (retval == 0)
8386                                 goto err_free_rel;
8387                               if (toc_tls != NULL)
8388                                 {
8389                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8390                                     found_tls_get_addr_arg = 1;
8391                                   if (retval > 1)
8392                                     toc_ref[toc_ref_index] = 1;
8393                                 }
8394                             }
8395                           continue;
8396                         }
8397
8398                       if (expecting_tls_get_addr != 1)
8399                         continue;
8400
8401                       /* Uh oh, we didn't find the expected call.  We
8402                          could just mark this symbol to exclude it
8403                          from tls optimization but it's safer to skip
8404                          the entire optimization.  */
8405                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8406                                                 "TLS optimization disabled\n"),
8407                                               ibfd, sec, rel->r_offset);
8408                       ret = TRUE;
8409                       goto err_free_rel;
8410                     }
8411
8412                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8413                     {
8414                       struct plt_entry *ent;
8415                       for (ent = htab->tls_get_addr->elf.plt.plist;
8416                            ent != NULL;
8417                            ent = ent->next)
8418                         if (ent->addend == 0)
8419                           {
8420                             if (ent->plt.refcount > 0)
8421                               {
8422                                 ent->plt.refcount -= 1;
8423                                 expecting_tls_get_addr = 0;
8424                               }
8425                             break;
8426                           }
8427                     }
8428
8429                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8430                     {
8431                       struct plt_entry *ent;
8432                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8433                            ent != NULL;
8434                            ent = ent->next)
8435                         if (ent->addend == 0)
8436                           {
8437                             if (ent->plt.refcount > 0)
8438                               ent->plt.refcount -= 1;
8439                             break;
8440                           }
8441                     }
8442
8443                   if (tls_clear == 0)
8444                     continue;
8445
8446                   if ((tls_set & TLS_EXPLICIT) == 0)
8447                     {
8448                       struct got_entry *ent;
8449
8450                       /* Adjust got entry for this reloc.  */
8451                       if (h != NULL)
8452                         ent = h->got.glist;
8453                       else
8454                         ent = elf_local_got_ents (ibfd)[r_symndx];
8455
8456                       for (; ent != NULL; ent = ent->next)
8457                         if (ent->addend == rel->r_addend
8458                             && ent->owner == ibfd
8459                             && ent->tls_type == tls_type)
8460                           break;
8461                       if (ent == NULL)
8462                         abort ();
8463
8464                       if (tls_set == 0)
8465                         {
8466                           /* We managed to get rid of a got entry.  */
8467                           if (ent->got.refcount > 0)
8468                             ent->got.refcount -= 1;
8469                         }
8470                     }
8471                   else
8472                     {
8473                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8474                          we'll lose one or two dyn relocs.  */
8475                       if (!dec_dynrel_count (rel->r_info, sec, info,
8476                                              NULL, h, sym))
8477                         return FALSE;
8478
8479                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8480                         {
8481                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8482                                                  NULL, h, sym))
8483                             return FALSE;
8484                         }
8485                     }
8486
8487                   *tls_mask |= tls_set;
8488                   *tls_mask &= ~tls_clear;
8489                 }
8490
8491               if (elf_section_data (sec)->relocs != relstart)
8492                 free (relstart);
8493             }
8494
8495         if (locsyms != NULL
8496             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8497           {
8498             if (!info->keep_memory)
8499               free (locsyms);
8500             else
8501               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8502           }
8503       }
8504
8505   if (toc_ref != NULL)
8506     free (toc_ref);
8507   return TRUE;
8508 }
8509
8510 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8511    the values of any global symbols in a toc section that has been
8512    edited.  Globals in toc sections should be a rarity, so this function
8513    sets a flag if any are found in toc sections other than the one just
8514    edited, so that futher hash table traversals can be avoided.  */
8515
8516 struct adjust_toc_info
8517 {
8518   asection *toc;
8519   unsigned long *skip;
8520   bfd_boolean global_toc_syms;
8521 };
8522
8523 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8524
8525 static bfd_boolean
8526 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8527 {
8528   struct ppc_link_hash_entry *eh;
8529   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8530   unsigned long i;
8531
8532   if (h->root.type != bfd_link_hash_defined
8533       && h->root.type != bfd_link_hash_defweak)
8534     return TRUE;
8535
8536   eh = (struct ppc_link_hash_entry *) h;
8537   if (eh->adjust_done)
8538     return TRUE;
8539
8540   if (eh->elf.root.u.def.section == toc_inf->toc)
8541     {
8542       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8543         i = toc_inf->toc->rawsize >> 3;
8544       else
8545         i = eh->elf.root.u.def.value >> 3;
8546
8547       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8548         {
8549           (*_bfd_error_handler)
8550             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8551           do
8552             ++i;
8553           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8554           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8555         }
8556
8557       eh->elf.root.u.def.value -= toc_inf->skip[i];
8558       eh->adjust_done = 1;
8559     }
8560   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8561     toc_inf->global_toc_syms = TRUE;
8562
8563   return TRUE;
8564 }
8565
8566 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8567
8568 static bfd_boolean
8569 ok_lo_toc_insn (unsigned int insn)
8570 {
8571   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8572           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8573           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8574           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8575           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8576           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8577           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8578           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8579           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8580           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8581           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8582           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8583           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8584           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8585           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8586               && (insn & 3) != 1)
8587           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8588               && ((insn & 3) == 0 || (insn & 3) == 3))
8589           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8590 }
8591
8592 /* Examine all relocs referencing .toc sections in order to remove
8593    unused .toc entries.  */
8594
8595 bfd_boolean
8596 ppc64_elf_edit_toc (struct bfd_link_info *info)
8597 {
8598   bfd *ibfd;
8599   struct adjust_toc_info toc_inf;
8600   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8601
8602   htab->do_toc_opt = 1;
8603   toc_inf.global_toc_syms = TRUE;
8604   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8605     {
8606       asection *toc, *sec;
8607       Elf_Internal_Shdr *symtab_hdr;
8608       Elf_Internal_Sym *local_syms;
8609       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8610       unsigned long *skip, *drop;
8611       unsigned char *used;
8612       unsigned char *keep, last, some_unused;
8613
8614       if (!is_ppc64_elf (ibfd))
8615         continue;
8616
8617       toc = bfd_get_section_by_name (ibfd, ".toc");
8618       if (toc == NULL
8619           || toc->size == 0
8620           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8621           || discarded_section (toc))
8622         continue;
8623
8624       toc_relocs = NULL;
8625       local_syms = NULL;
8626       symtab_hdr = &elf_symtab_hdr (ibfd);
8627
8628       /* Look at sections dropped from the final link.  */
8629       skip = NULL;
8630       relstart = NULL;
8631       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8632         {
8633           if (sec->reloc_count == 0
8634               || !discarded_section (sec)
8635               || get_opd_info (sec)
8636               || (sec->flags & SEC_ALLOC) == 0
8637               || (sec->flags & SEC_DEBUGGING) != 0)
8638             continue;
8639
8640           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8641           if (relstart == NULL)
8642             goto error_ret;
8643
8644           /* Run through the relocs to see which toc entries might be
8645              unused.  */
8646           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8647             {
8648               enum elf_ppc64_reloc_type r_type;
8649               unsigned long r_symndx;
8650               asection *sym_sec;
8651               struct elf_link_hash_entry *h;
8652               Elf_Internal_Sym *sym;
8653               bfd_vma val;
8654
8655               r_type = ELF64_R_TYPE (rel->r_info);
8656               switch (r_type)
8657                 {
8658                 default:
8659                   continue;
8660
8661                 case R_PPC64_TOC16:
8662                 case R_PPC64_TOC16_LO:
8663                 case R_PPC64_TOC16_HI:
8664                 case R_PPC64_TOC16_HA:
8665                 case R_PPC64_TOC16_DS:
8666                 case R_PPC64_TOC16_LO_DS:
8667                   break;
8668                 }
8669
8670               r_symndx = ELF64_R_SYM (rel->r_info);
8671               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8672                               r_symndx, ibfd))
8673                 goto error_ret;
8674
8675               if (sym_sec != toc)
8676                 continue;
8677
8678               if (h != NULL)
8679                 val = h->root.u.def.value;
8680               else
8681                 val = sym->st_value;
8682               val += rel->r_addend;
8683
8684               if (val >= toc->size)
8685                 continue;
8686
8687               /* Anything in the toc ought to be aligned to 8 bytes.
8688                  If not, don't mark as unused.  */
8689               if (val & 7)
8690                 continue;
8691
8692               if (skip == NULL)
8693                 {
8694                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8695                   if (skip == NULL)
8696                     goto error_ret;
8697                 }
8698
8699               skip[val >> 3] = ref_from_discarded;
8700             }
8701
8702           if (elf_section_data (sec)->relocs != relstart)
8703             free (relstart);
8704         }
8705
8706       /* For largetoc loads of address constants, we can convert
8707          .  addis rx,2,addr@got@ha
8708          .  ld ry,addr@got@l(rx)
8709          to
8710          .  addis rx,2,addr@toc@ha
8711          .  addi ry,rx,addr@toc@l
8712          when addr is within 2G of the toc pointer.  This then means
8713          that the word storing "addr" in the toc is no longer needed.  */
8714
8715       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8716           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8717           && toc->reloc_count != 0)
8718         {
8719           /* Read toc relocs.  */
8720           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8721                                                   info->keep_memory);
8722           if (toc_relocs == NULL)
8723             goto error_ret;
8724
8725           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8726             {
8727               enum elf_ppc64_reloc_type r_type;
8728               unsigned long r_symndx;
8729               asection *sym_sec;
8730               struct elf_link_hash_entry *h;
8731               Elf_Internal_Sym *sym;
8732               bfd_vma val, addr;
8733
8734               r_type = ELF64_R_TYPE (rel->r_info);
8735               if (r_type != R_PPC64_ADDR64)
8736                 continue;
8737
8738               r_symndx = ELF64_R_SYM (rel->r_info);
8739               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8740                               r_symndx, ibfd))
8741                 goto error_ret;
8742
8743               if (sym_sec == NULL
8744                   || discarded_section (sym_sec))
8745                 continue;
8746
8747               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8748                 continue;
8749
8750               if (h != NULL)
8751                 {
8752                   if (h->type == STT_GNU_IFUNC)
8753                     continue;
8754                   val = h->root.u.def.value;
8755                 }
8756               else
8757                 {
8758                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8759                     continue;
8760                   val = sym->st_value;
8761                 }
8762               val += rel->r_addend;
8763               val += sym_sec->output_section->vma + sym_sec->output_offset;
8764
8765               /* We don't yet know the exact toc pointer value, but we
8766                  know it will be somewhere in the toc section.  Don't
8767                  optimize if the difference from any possible toc
8768                  pointer is outside [ff..f80008000, 7fff7fff].  */
8769               addr = toc->output_section->vma + TOC_BASE_OFF;
8770               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8771                 continue;
8772
8773               addr = toc->output_section->vma + toc->output_section->rawsize;
8774               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8775                 continue;
8776
8777               if (skip == NULL)
8778                 {
8779                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8780                   if (skip == NULL)
8781                     goto error_ret;
8782                 }
8783
8784               skip[rel->r_offset >> 3]
8785                 |= can_optimize | ((rel - toc_relocs) << 2);
8786             }
8787         }
8788
8789       if (skip == NULL)
8790         continue;
8791
8792       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8793       if (used == NULL)
8794         {
8795         error_ret:
8796           if (local_syms != NULL
8797               && symtab_hdr->contents != (unsigned char *) local_syms)
8798             free (local_syms);
8799           if (sec != NULL
8800               && relstart != NULL
8801               && elf_section_data (sec)->relocs != relstart)
8802             free (relstart);
8803           if (toc_relocs != NULL
8804               && elf_section_data (toc)->relocs != toc_relocs)
8805             free (toc_relocs);
8806           if (skip != NULL)
8807             free (skip);
8808           return FALSE;
8809         }
8810
8811       /* Now check all kept sections that might reference the toc.
8812          Check the toc itself last.  */
8813       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8814                   : ibfd->sections);
8815            sec != NULL;
8816            sec = (sec == toc ? NULL
8817                   : sec->next == NULL ? toc
8818                   : sec->next == toc && toc->next ? toc->next
8819                   : sec->next))
8820         {
8821           int repeat;
8822
8823           if (sec->reloc_count == 0
8824               || discarded_section (sec)
8825               || get_opd_info (sec)
8826               || (sec->flags & SEC_ALLOC) == 0
8827               || (sec->flags & SEC_DEBUGGING) != 0)
8828             continue;
8829
8830           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8831                                                 info->keep_memory);
8832           if (relstart == NULL)
8833             {
8834               free (used);
8835               goto error_ret;
8836             }
8837
8838           /* Mark toc entries referenced as used.  */
8839           do
8840             {
8841               repeat = 0;
8842               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8843                 {
8844                   enum elf_ppc64_reloc_type r_type;
8845                   unsigned long r_symndx;
8846                   asection *sym_sec;
8847                   struct elf_link_hash_entry *h;
8848                   Elf_Internal_Sym *sym;
8849                   bfd_vma val;
8850                   enum {no_check, check_lo, check_ha} insn_check;
8851
8852                   r_type = ELF64_R_TYPE (rel->r_info);
8853                   switch (r_type)
8854                     {
8855                     default:
8856                       insn_check = no_check;
8857                       break;
8858
8859                     case R_PPC64_GOT_TLSLD16_HA:
8860                     case R_PPC64_GOT_TLSGD16_HA:
8861                     case R_PPC64_GOT_TPREL16_HA:
8862                     case R_PPC64_GOT_DTPREL16_HA:
8863                     case R_PPC64_GOT16_HA:
8864                     case R_PPC64_TOC16_HA:
8865                       insn_check = check_ha;
8866                       break;
8867
8868                     case R_PPC64_GOT_TLSLD16_LO:
8869                     case R_PPC64_GOT_TLSGD16_LO:
8870                     case R_PPC64_GOT_TPREL16_LO_DS:
8871                     case R_PPC64_GOT_DTPREL16_LO_DS:
8872                     case R_PPC64_GOT16_LO:
8873                     case R_PPC64_GOT16_LO_DS:
8874                     case R_PPC64_TOC16_LO:
8875                     case R_PPC64_TOC16_LO_DS:
8876                       insn_check = check_lo;
8877                       break;
8878                     }
8879
8880                   if (insn_check != no_check)
8881                     {
8882                       bfd_vma off = rel->r_offset & ~3;
8883                       unsigned char buf[4];
8884                       unsigned int insn;
8885
8886                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8887                         {
8888                           free (used);
8889                           goto error_ret;
8890                         }
8891                       insn = bfd_get_32 (ibfd, buf);
8892                       if (insn_check == check_lo
8893                           ? !ok_lo_toc_insn (insn)
8894                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8895                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8896                         {
8897                           char str[12];
8898
8899                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8900                           sprintf (str, "%#08x", insn);
8901                           info->callbacks->einfo
8902                             (_("%P: %H: toc optimization is not supported for"
8903                                " %s instruction.\n"),
8904                              ibfd, sec, rel->r_offset & ~3, str);
8905                         }
8906                     }
8907
8908                   switch (r_type)
8909                     {
8910                     case R_PPC64_TOC16:
8911                     case R_PPC64_TOC16_LO:
8912                     case R_PPC64_TOC16_HI:
8913                     case R_PPC64_TOC16_HA:
8914                     case R_PPC64_TOC16_DS:
8915                     case R_PPC64_TOC16_LO_DS:
8916                       /* In case we're taking addresses of toc entries.  */
8917                     case R_PPC64_ADDR64:
8918                       break;
8919
8920                     default:
8921                       continue;
8922                     }
8923
8924                   r_symndx = ELF64_R_SYM (rel->r_info);
8925                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8926                                   r_symndx, ibfd))
8927                     {
8928                       free (used);
8929                       goto error_ret;
8930                     }
8931
8932                   if (sym_sec != toc)
8933                     continue;
8934
8935                   if (h != NULL)
8936                     val = h->root.u.def.value;
8937                   else
8938                     val = sym->st_value;
8939                   val += rel->r_addend;
8940
8941                   if (val >= toc->size)
8942                     continue;
8943
8944                   if ((skip[val >> 3] & can_optimize) != 0)
8945                     {
8946                       bfd_vma off;
8947                       unsigned char opc;
8948
8949                       switch (r_type)
8950                         {
8951                         case R_PPC64_TOC16_HA:
8952                           break;
8953
8954                         case R_PPC64_TOC16_LO_DS:
8955                           off = rel->r_offset;
8956                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8957                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8958                                                          off, 1))
8959                             {
8960                               free (used);
8961                               goto error_ret;
8962                             }
8963                           if ((opc & (0x3f << 2)) == (58u << 2))
8964                             break;
8965                           /* Fall thru */
8966
8967                         default:
8968                           /* Wrong sort of reloc, or not a ld.  We may
8969                              as well clear ref_from_discarded too.  */
8970                           skip[val >> 3] = 0;
8971                         }
8972                     }
8973
8974                   if (sec != toc)
8975                     used[val >> 3] = 1;
8976                   /* For the toc section, we only mark as used if this
8977                      entry itself isn't unused.  */
8978                   else if ((used[rel->r_offset >> 3]
8979                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8980                            && !used[val >> 3])
8981                     {
8982                       /* Do all the relocs again, to catch reference
8983                          chains.  */
8984                       repeat = 1;
8985                       used[val >> 3] = 1;
8986                     }
8987                 }
8988             }
8989           while (repeat);
8990
8991           if (elf_section_data (sec)->relocs != relstart)
8992             free (relstart);
8993         }
8994
8995       /* Merge the used and skip arrays.  Assume that TOC
8996          doublewords not appearing as either used or unused belong
8997          to to an entry more than one doubleword in size.  */
8998       for (drop = skip, keep = used, last = 0, some_unused = 0;
8999            drop < skip + (toc->size + 7) / 8;
9000            ++drop, ++keep)
9001         {
9002           if (*keep)
9003             {
9004               *drop &= ~ref_from_discarded;
9005               if ((*drop & can_optimize) != 0)
9006                 some_unused = 1;
9007               last = 0;
9008             }
9009           else if ((*drop & ref_from_discarded) != 0)
9010             {
9011               some_unused = 1;
9012               last = ref_from_discarded;
9013             }
9014           else
9015             *drop = last;
9016         }
9017
9018       free (used);
9019
9020       if (some_unused)
9021         {
9022           bfd_byte *contents, *src;
9023           unsigned long off;
9024           Elf_Internal_Sym *sym;
9025           bfd_boolean local_toc_syms = FALSE;
9026
9027           /* Shuffle the toc contents, and at the same time convert the
9028              skip array from booleans into offsets.  */
9029           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9030             goto error_ret;
9031
9032           elf_section_data (toc)->this_hdr.contents = contents;
9033
9034           for (src = contents, off = 0, drop = skip;
9035                src < contents + toc->size;
9036                src += 8, ++drop)
9037             {
9038               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9039                 off += 8;
9040               else if (off != 0)
9041                 {
9042                   *drop = off;
9043                   memcpy (src - off, src, 8);
9044                 }
9045             }
9046           *drop = off;
9047           toc->rawsize = toc->size;
9048           toc->size = src - contents - off;
9049
9050           /* Adjust addends for relocs against the toc section sym,
9051              and optimize any accesses we can.  */
9052           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9053             {
9054               if (sec->reloc_count == 0
9055                   || discarded_section (sec))
9056                 continue;
9057
9058               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9059                                                     info->keep_memory);
9060               if (relstart == NULL)
9061                 goto error_ret;
9062
9063               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9064                 {
9065                   enum elf_ppc64_reloc_type r_type;
9066                   unsigned long r_symndx;
9067                   asection *sym_sec;
9068                   struct elf_link_hash_entry *h;
9069                   bfd_vma val;
9070
9071                   r_type = ELF64_R_TYPE (rel->r_info);
9072                   switch (r_type)
9073                     {
9074                     default:
9075                       continue;
9076
9077                     case R_PPC64_TOC16:
9078                     case R_PPC64_TOC16_LO:
9079                     case R_PPC64_TOC16_HI:
9080                     case R_PPC64_TOC16_HA:
9081                     case R_PPC64_TOC16_DS:
9082                     case R_PPC64_TOC16_LO_DS:
9083                     case R_PPC64_ADDR64:
9084                       break;
9085                     }
9086
9087                   r_symndx = ELF64_R_SYM (rel->r_info);
9088                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9089                                   r_symndx, ibfd))
9090                     goto error_ret;
9091
9092                   if (sym_sec != toc)
9093                     continue;
9094
9095                   if (h != NULL)
9096                     val = h->root.u.def.value;
9097                   else
9098                     {
9099                       val = sym->st_value;
9100                       if (val != 0)
9101                         local_toc_syms = TRUE;
9102                     }
9103
9104                   val += rel->r_addend;
9105
9106                   if (val > toc->rawsize)
9107                     val = toc->rawsize;
9108                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9109                     continue;
9110                   else if ((skip[val >> 3] & can_optimize) != 0)
9111                     {
9112                       Elf_Internal_Rela *tocrel
9113                         = toc_relocs + (skip[val >> 3] >> 2);
9114                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9115
9116                       switch (r_type)
9117                         {
9118                         case R_PPC64_TOC16_HA:
9119                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9120                           break;
9121
9122                         case R_PPC64_TOC16_LO_DS:
9123                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9124                           break;
9125
9126                         default:
9127                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9128                             ppc_howto_init ();
9129                           info->callbacks->einfo
9130                             (_("%P: %H: %s references "
9131                                "optimized away TOC entry\n"),
9132                              ibfd, sec, rel->r_offset,
9133                              ppc64_elf_howto_table[r_type]->name);
9134                           bfd_set_error (bfd_error_bad_value);
9135                           goto error_ret;
9136                         }
9137                       rel->r_addend = tocrel->r_addend;
9138                       elf_section_data (sec)->relocs = relstart;
9139                       continue;
9140                     }
9141
9142                   if (h != NULL || sym->st_value != 0)
9143                     continue;
9144
9145                   rel->r_addend -= skip[val >> 3];
9146                   elf_section_data (sec)->relocs = relstart;
9147                 }
9148
9149               if (elf_section_data (sec)->relocs != relstart)
9150                 free (relstart);
9151             }
9152
9153           /* We shouldn't have local or global symbols defined in the TOC,
9154              but handle them anyway.  */
9155           if (local_syms != NULL)
9156             for (sym = local_syms;
9157                  sym < local_syms + symtab_hdr->sh_info;
9158                  ++sym)
9159               if (sym->st_value != 0
9160                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9161                 {
9162                   unsigned long i;
9163
9164                   if (sym->st_value > toc->rawsize)
9165                     i = toc->rawsize >> 3;
9166                   else
9167                     i = sym->st_value >> 3;
9168
9169                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9170                     {
9171                       if (local_toc_syms)
9172                         (*_bfd_error_handler)
9173                           (_("%s defined on removed toc entry"),
9174                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9175                       do
9176                         ++i;
9177                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9178                       sym->st_value = (bfd_vma) i << 3;
9179                     }
9180
9181                   sym->st_value -= skip[i];
9182                   symtab_hdr->contents = (unsigned char *) local_syms;
9183                 }
9184
9185           /* Adjust any global syms defined in this toc input section.  */
9186           if (toc_inf.global_toc_syms)
9187             {
9188               toc_inf.toc = toc;
9189               toc_inf.skip = skip;
9190               toc_inf.global_toc_syms = FALSE;
9191               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9192                                       &toc_inf);
9193             }
9194
9195           if (toc->reloc_count != 0)
9196             {
9197               Elf_Internal_Shdr *rel_hdr;
9198               Elf_Internal_Rela *wrel;
9199               bfd_size_type sz;
9200
9201               /* Remove unused toc relocs, and adjust those we keep.  */
9202               if (toc_relocs == NULL)
9203                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9204                                                         info->keep_memory);
9205               if (toc_relocs == NULL)
9206                 goto error_ret;
9207
9208               wrel = toc_relocs;
9209               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9210                 if ((skip[rel->r_offset >> 3]
9211                      & (ref_from_discarded | can_optimize)) == 0)
9212                   {
9213                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9214                     wrel->r_info = rel->r_info;
9215                     wrel->r_addend = rel->r_addend;
9216                     ++wrel;
9217                   }
9218                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9219                                             &local_syms, NULL, NULL))
9220                   goto error_ret;
9221
9222               elf_section_data (toc)->relocs = toc_relocs;
9223               toc->reloc_count = wrel - toc_relocs;
9224               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9225               sz = rel_hdr->sh_entsize;
9226               rel_hdr->sh_size = toc->reloc_count * sz;
9227             }
9228         }
9229       else if (toc_relocs != NULL
9230                && elf_section_data (toc)->relocs != toc_relocs)
9231         free (toc_relocs);
9232
9233       if (local_syms != NULL
9234           && symtab_hdr->contents != (unsigned char *) local_syms)
9235         {
9236           if (!info->keep_memory)
9237             free (local_syms);
9238           else
9239             symtab_hdr->contents = (unsigned char *) local_syms;
9240         }
9241       free (skip);
9242     }
9243
9244   return TRUE;
9245 }
9246
9247 /* Return true iff input section I references the TOC using
9248    instructions limited to +/-32k offsets.  */
9249
9250 bfd_boolean
9251 ppc64_elf_has_small_toc_reloc (asection *i)
9252 {
9253   return (is_ppc64_elf (i->owner)
9254           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9255 }
9256
9257 /* Allocate space for one GOT entry.  */
9258
9259 static void
9260 allocate_got (struct elf_link_hash_entry *h,
9261               struct bfd_link_info *info,
9262               struct got_entry *gent)
9263 {
9264   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9265   bfd_boolean dyn;
9266   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9267   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9268                  ? 16 : 8);
9269   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9270                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9271   asection *got = ppc64_elf_tdata (gent->owner)->got;
9272
9273   gent->got.offset = got->size;
9274   got->size += entsize;
9275
9276   dyn = htab->elf.dynamic_sections_created;
9277   if (h->type == STT_GNU_IFUNC)
9278     {
9279       htab->elf.irelplt->size += rentsize;
9280       htab->got_reli_size += rentsize;
9281     }
9282   else if ((info->shared
9283             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9284            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9285                || h->root.type != bfd_link_hash_undefweak))
9286     {
9287       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9288       relgot->size += rentsize;
9289     }
9290 }
9291
9292 /* This function merges got entries in the same toc group.  */
9293
9294 static void
9295 merge_got_entries (struct got_entry **pent)
9296 {
9297   struct got_entry *ent, *ent2;
9298
9299   for (ent = *pent; ent != NULL; ent = ent->next)
9300     if (!ent->is_indirect)
9301       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9302         if (!ent2->is_indirect
9303             && ent2->addend == ent->addend
9304             && ent2->tls_type == ent->tls_type
9305             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9306           {
9307             ent2->is_indirect = TRUE;
9308             ent2->got.ent = ent;
9309           }
9310 }
9311
9312 /* Allocate space in .plt, .got and associated reloc sections for
9313    dynamic relocs.  */
9314
9315 static bfd_boolean
9316 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9317 {
9318   struct bfd_link_info *info;
9319   struct ppc_link_hash_table *htab;
9320   asection *s;
9321   struct ppc_link_hash_entry *eh;
9322   struct elf_dyn_relocs *p;
9323   struct got_entry **pgent, *gent;
9324
9325   if (h->root.type == bfd_link_hash_indirect)
9326     return TRUE;
9327
9328   info = (struct bfd_link_info *) inf;
9329   htab = ppc_hash_table (info);
9330   if (htab == NULL)
9331     return FALSE;
9332
9333   if ((htab->elf.dynamic_sections_created
9334        && h->dynindx != -1
9335        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9336       || h->type == STT_GNU_IFUNC)
9337     {
9338       struct plt_entry *pent;
9339       bfd_boolean doneone = FALSE;
9340       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9341         if (pent->plt.refcount > 0)
9342           {
9343             if (!htab->elf.dynamic_sections_created
9344                 || h->dynindx == -1)
9345               {
9346                 s = htab->elf.iplt;
9347                 pent->plt.offset = s->size;
9348                 s->size += PLT_ENTRY_SIZE (htab);
9349                 s = htab->elf.irelplt;
9350               }
9351             else
9352               {
9353                 /* If this is the first .plt entry, make room for the special
9354                    first entry.  */
9355                 s = htab->elf.splt;
9356                 if (s->size == 0)
9357                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9358
9359                 pent->plt.offset = s->size;
9360
9361                 /* Make room for this entry.  */
9362                 s->size += PLT_ENTRY_SIZE (htab);
9363
9364                 /* Make room for the .glink code.  */
9365                 s = htab->glink;
9366                 if (s->size == 0)
9367                   s->size += GLINK_CALL_STUB_SIZE;
9368                 if (htab->opd_abi)
9369                   {
9370                     /* We need bigger stubs past index 32767.  */
9371                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9372                       s->size += 4;
9373                     s->size += 2*4;
9374                   }
9375                 else
9376                   s->size += 4;
9377
9378                 /* We also need to make an entry in the .rela.plt section.  */
9379                 s = htab->elf.srelplt;
9380               }
9381             s->size += sizeof (Elf64_External_Rela);
9382             doneone = TRUE;
9383           }
9384         else
9385           pent->plt.offset = (bfd_vma) -1;
9386       if (!doneone)
9387         {
9388           h->plt.plist = NULL;
9389           h->needs_plt = 0;
9390         }
9391     }
9392   else
9393     {
9394       h->plt.plist = NULL;
9395       h->needs_plt = 0;
9396     }
9397
9398   eh = (struct ppc_link_hash_entry *) h;
9399   /* Run through the TLS GD got entries first if we're changing them
9400      to TPREL.  */
9401   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9402     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9403       if (gent->got.refcount > 0
9404           && (gent->tls_type & TLS_GD) != 0)
9405         {
9406           /* This was a GD entry that has been converted to TPREL.  If
9407              there happens to be a TPREL entry we can use that one.  */
9408           struct got_entry *ent;
9409           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9410             if (ent->got.refcount > 0
9411                 && (ent->tls_type & TLS_TPREL) != 0
9412                 && ent->addend == gent->addend
9413                 && ent->owner == gent->owner)
9414               {
9415                 gent->got.refcount = 0;
9416                 break;
9417               }
9418
9419           /* If not, then we'll be using our own TPREL entry.  */
9420           if (gent->got.refcount != 0)
9421             gent->tls_type = TLS_TLS | TLS_TPREL;
9422         }
9423
9424   /* Remove any list entry that won't generate a word in the GOT before
9425      we call merge_got_entries.  Otherwise we risk merging to empty
9426      entries.  */
9427   pgent = &h->got.glist;
9428   while ((gent = *pgent) != NULL)
9429     if (gent->got.refcount > 0)
9430       {
9431         if ((gent->tls_type & TLS_LD) != 0
9432             && !h->def_dynamic)
9433           {
9434             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9435             *pgent = gent->next;
9436           }
9437         else
9438           pgent = &gent->next;
9439       }
9440     else
9441       *pgent = gent->next;
9442
9443   if (!htab->do_multi_toc)
9444     merge_got_entries (&h->got.glist);
9445
9446   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9447     if (!gent->is_indirect)
9448       {
9449         /* Make sure this symbol is output as a dynamic symbol.
9450            Undefined weak syms won't yet be marked as dynamic,
9451            nor will all TLS symbols.  */
9452         if (h->dynindx == -1
9453             && !h->forced_local
9454             && h->type != STT_GNU_IFUNC
9455             && htab->elf.dynamic_sections_created)
9456           {
9457             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9458               return FALSE;
9459           }
9460
9461         if (!is_ppc64_elf (gent->owner))
9462           abort ();
9463
9464         allocate_got (h, info, gent);
9465       }
9466
9467   if (eh->dyn_relocs == NULL
9468       || (!htab->elf.dynamic_sections_created
9469           && h->type != STT_GNU_IFUNC))
9470     return TRUE;
9471
9472   /* In the shared -Bsymbolic case, discard space allocated for
9473      dynamic pc-relative relocs against symbols which turn out to be
9474      defined in regular objects.  For the normal shared case, discard
9475      space for relocs that have become local due to symbol visibility
9476      changes.  */
9477
9478   if (info->shared)
9479     {
9480       /* Relocs that use pc_count are those that appear on a call insn,
9481          or certain REL relocs (see must_be_dyn_reloc) that can be
9482          generated via assembly.  We want calls to protected symbols to
9483          resolve directly to the function rather than going via the plt.
9484          If people want function pointer comparisons to work as expected
9485          then they should avoid writing weird assembly.  */
9486       if (SYMBOL_CALLS_LOCAL (info, h))
9487         {
9488           struct elf_dyn_relocs **pp;
9489
9490           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9491             {
9492               p->count -= p->pc_count;
9493               p->pc_count = 0;
9494               if (p->count == 0)
9495                 *pp = p->next;
9496               else
9497                 pp = &p->next;
9498             }
9499         }
9500
9501       /* Also discard relocs on undefined weak syms with non-default
9502          visibility.  */
9503       if (eh->dyn_relocs != NULL
9504           && h->root.type == bfd_link_hash_undefweak)
9505         {
9506           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9507             eh->dyn_relocs = NULL;
9508
9509           /* Make sure this symbol is output as a dynamic symbol.
9510              Undefined weak syms won't yet be marked as dynamic.  */
9511           else if (h->dynindx == -1
9512                    && !h->forced_local)
9513             {
9514               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9515                 return FALSE;
9516             }
9517         }
9518     }
9519   else if (h->type == STT_GNU_IFUNC)
9520     {
9521       if (!h->non_got_ref)
9522         eh->dyn_relocs = NULL;
9523     }
9524   else if (ELIMINATE_COPY_RELOCS)
9525     {
9526       /* For the non-shared case, discard space for relocs against
9527          symbols which turn out to need copy relocs or are not
9528          dynamic.  */
9529
9530       if (!h->non_got_ref
9531           && !h->def_regular)
9532         {
9533           /* Make sure this symbol is output as a dynamic symbol.
9534              Undefined weak syms won't yet be marked as dynamic.  */
9535           if (h->dynindx == -1
9536               && !h->forced_local)
9537             {
9538               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9539                 return FALSE;
9540             }
9541
9542           /* If that succeeded, we know we'll be keeping all the
9543              relocs.  */
9544           if (h->dynindx != -1)
9545             goto keep;
9546         }
9547
9548       eh->dyn_relocs = NULL;
9549
9550     keep: ;
9551     }
9552
9553   /* Finally, allocate space.  */
9554   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9555     {
9556       asection *sreloc = elf_section_data (p->sec)->sreloc;
9557       if (eh->elf.type == STT_GNU_IFUNC)
9558         sreloc = htab->elf.irelplt;
9559       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9560     }
9561
9562   return TRUE;
9563 }
9564
9565 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9566    to set up space for global entry stubs.  These are put in glink,
9567    after the branch table.  */
9568
9569 static bfd_boolean
9570 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9571 {
9572   struct bfd_link_info *info;
9573   struct ppc_link_hash_table *htab;
9574   struct plt_entry *pent;
9575   asection *s;
9576
9577   if (h->root.type == bfd_link_hash_indirect)
9578     return TRUE;
9579
9580   if (!h->pointer_equality_needed)
9581     return TRUE;
9582
9583   if (h->def_regular)
9584     return TRUE;
9585
9586   info = inf;
9587   htab = ppc_hash_table (info);
9588   if (htab == NULL)
9589     return FALSE;
9590
9591   s = htab->glink;
9592   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9593     if (pent->plt.offset != (bfd_vma) -1
9594         && pent->addend == 0)
9595       {
9596         /* For ELFv2, if this symbol is not defined in a regular file
9597            and we are not generating a shared library or pie, then we
9598            need to define the symbol in the executable on a call stub.
9599            This is to avoid text relocations.  */
9600         s->size = (s->size + 15) & -16;
9601         h->root.u.def.section = s;
9602         h->root.u.def.value = s->size;
9603         s->size += 16;
9604         break;
9605       }
9606   return TRUE;
9607 }
9608
9609 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9610    read-only sections.  */
9611
9612 static bfd_boolean
9613 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9614 {
9615   if (h->root.type == bfd_link_hash_indirect)
9616     return TRUE;
9617
9618   if (readonly_dynrelocs (h))
9619     {
9620       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9621
9622       /* Not an error, just cut short the traversal.  */
9623       return FALSE;
9624     }
9625   return TRUE;
9626 }
9627
9628 /* Set the sizes of the dynamic sections.  */
9629
9630 static bfd_boolean
9631 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9632                                  struct bfd_link_info *info)
9633 {
9634   struct ppc_link_hash_table *htab;
9635   bfd *dynobj;
9636   asection *s;
9637   bfd_boolean relocs;
9638   bfd *ibfd;
9639   struct got_entry *first_tlsld;
9640
9641   htab = ppc_hash_table (info);
9642   if (htab == NULL)
9643     return FALSE;
9644
9645   dynobj = htab->elf.dynobj;
9646   if (dynobj == NULL)
9647     abort ();
9648
9649   if (htab->elf.dynamic_sections_created)
9650     {
9651       /* Set the contents of the .interp section to the interpreter.  */
9652       if (info->executable)
9653         {
9654           s = bfd_get_linker_section (dynobj, ".interp");
9655           if (s == NULL)
9656             abort ();
9657           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9658           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9659         }
9660     }
9661
9662   /* Set up .got offsets for local syms, and space for local dynamic
9663      relocs.  */
9664   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9665     {
9666       struct got_entry **lgot_ents;
9667       struct got_entry **end_lgot_ents;
9668       struct plt_entry **local_plt;
9669       struct plt_entry **end_local_plt;
9670       unsigned char *lgot_masks;
9671       bfd_size_type locsymcount;
9672       Elf_Internal_Shdr *symtab_hdr;
9673
9674       if (!is_ppc64_elf (ibfd))
9675         continue;
9676
9677       for (s = ibfd->sections; s != NULL; s = s->next)
9678         {
9679           struct ppc_dyn_relocs *p;
9680
9681           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9682             {
9683               if (!bfd_is_abs_section (p->sec)
9684                   && bfd_is_abs_section (p->sec->output_section))
9685                 {
9686                   /* Input section has been discarded, either because
9687                      it is a copy of a linkonce section or due to
9688                      linker script /DISCARD/, so we'll be discarding
9689                      the relocs too.  */
9690                 }
9691               else if (p->count != 0)
9692                 {
9693                   asection *srel = elf_section_data (p->sec)->sreloc;
9694                   if (p->ifunc)
9695                     srel = htab->elf.irelplt;
9696                   srel->size += p->count * sizeof (Elf64_External_Rela);
9697                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9698                     info->flags |= DF_TEXTREL;
9699                 }
9700             }
9701         }
9702
9703       lgot_ents = elf_local_got_ents (ibfd);
9704       if (!lgot_ents)
9705         continue;
9706
9707       symtab_hdr = &elf_symtab_hdr (ibfd);
9708       locsymcount = symtab_hdr->sh_info;
9709       end_lgot_ents = lgot_ents + locsymcount;
9710       local_plt = (struct plt_entry **) end_lgot_ents;
9711       end_local_plt = local_plt + locsymcount;
9712       lgot_masks = (unsigned char *) end_local_plt;
9713       s = ppc64_elf_tdata (ibfd)->got;
9714       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9715         {
9716           struct got_entry **pent, *ent;
9717
9718           pent = lgot_ents;
9719           while ((ent = *pent) != NULL)
9720             if (ent->got.refcount > 0)
9721               {
9722                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9723                   {
9724                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9725                     *pent = ent->next;
9726                   }
9727                 else
9728                   {
9729                     unsigned int ent_size = 8;
9730                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9731
9732                     ent->got.offset = s->size;
9733                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9734                       {
9735                         ent_size *= 2;
9736                         rel_size *= 2;
9737                       }
9738                     s->size += ent_size;
9739                     if ((*lgot_masks & PLT_IFUNC) != 0)
9740                       {
9741                         htab->elf.irelplt->size += rel_size;
9742                         htab->got_reli_size += rel_size;
9743                       }
9744                     else if (info->shared)
9745                       {
9746                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9747                         srel->size += rel_size;
9748                       }
9749                     pent = &ent->next;
9750                   }
9751               }
9752             else
9753               *pent = ent->next;
9754         }
9755
9756       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9757       for (; local_plt < end_local_plt; ++local_plt)
9758         {
9759           struct plt_entry *ent;
9760
9761           for (ent = *local_plt; ent != NULL; ent = ent->next)
9762             if (ent->plt.refcount > 0)
9763               {
9764                 s = htab->elf.iplt;
9765                 ent->plt.offset = s->size;
9766                 s->size += PLT_ENTRY_SIZE (htab);
9767
9768                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9769               }
9770             else
9771               ent->plt.offset = (bfd_vma) -1;
9772         }
9773     }
9774
9775   /* Allocate global sym .plt and .got entries, and space for global
9776      sym dynamic relocs.  */
9777   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9778   /* Stash the end of glink branch table.  */
9779   if (htab->glink != NULL)
9780     htab->glink->rawsize = htab->glink->size;
9781
9782   if (!htab->opd_abi && !info->shared)
9783     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9784
9785   first_tlsld = NULL;
9786   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9787     {
9788       struct got_entry *ent;
9789
9790       if (!is_ppc64_elf (ibfd))
9791         continue;
9792
9793       ent = ppc64_tlsld_got (ibfd);
9794       if (ent->got.refcount > 0)
9795         {
9796           if (!htab->do_multi_toc && first_tlsld != NULL)
9797             {
9798               ent->is_indirect = TRUE;
9799               ent->got.ent = first_tlsld;
9800             }
9801           else
9802             {
9803               if (first_tlsld == NULL)
9804                 first_tlsld = ent;
9805               s = ppc64_elf_tdata (ibfd)->got;
9806               ent->got.offset = s->size;
9807               ent->owner = ibfd;
9808               s->size += 16;
9809               if (info->shared)
9810                 {
9811                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9812                   srel->size += sizeof (Elf64_External_Rela);
9813                 }
9814             }
9815         }
9816       else
9817         ent->got.offset = (bfd_vma) -1;
9818     }
9819
9820   /* We now have determined the sizes of the various dynamic sections.
9821      Allocate memory for them.  */
9822   relocs = FALSE;
9823   for (s = dynobj->sections; s != NULL; s = s->next)
9824     {
9825       if ((s->flags & SEC_LINKER_CREATED) == 0)
9826         continue;
9827
9828       if (s == htab->brlt || s == htab->relbrlt)
9829         /* These haven't been allocated yet;  don't strip.  */
9830         continue;
9831       else if (s == htab->elf.sgot
9832                || s == htab->elf.splt
9833                || s == htab->elf.iplt
9834                || s == htab->glink
9835                || s == htab->dynbss)
9836         {
9837           /* Strip this section if we don't need it; see the
9838              comment below.  */
9839         }
9840       else if (s == htab->glink_eh_frame)
9841         {
9842           if (!bfd_is_abs_section (s->output_section))
9843             /* Not sized yet.  */
9844             continue;
9845         }
9846       else if (CONST_STRNEQ (s->name, ".rela"))
9847         {
9848           if (s->size != 0)
9849             {
9850               if (s != htab->elf.srelplt)
9851                 relocs = TRUE;
9852
9853               /* We use the reloc_count field as a counter if we need
9854                  to copy relocs into the output file.  */
9855               s->reloc_count = 0;
9856             }
9857         }
9858       else
9859         {
9860           /* It's not one of our sections, so don't allocate space.  */
9861           continue;
9862         }
9863
9864       if (s->size == 0)
9865         {
9866           /* If we don't need this section, strip it from the
9867              output file.  This is mostly to handle .rela.bss and
9868              .rela.plt.  We must create both sections in
9869              create_dynamic_sections, because they must be created
9870              before the linker maps input sections to output
9871              sections.  The linker does that before
9872              adjust_dynamic_symbol is called, and it is that
9873              function which decides whether anything needs to go
9874              into these sections.  */
9875           s->flags |= SEC_EXCLUDE;
9876           continue;
9877         }
9878
9879       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9880         continue;
9881
9882       /* Allocate memory for the section contents.  We use bfd_zalloc
9883          here in case unused entries are not reclaimed before the
9884          section's contents are written out.  This should not happen,
9885          but this way if it does we get a R_PPC64_NONE reloc in .rela
9886          sections instead of garbage.
9887          We also rely on the section contents being zero when writing
9888          the GOT.  */
9889       s->contents = bfd_zalloc (dynobj, s->size);
9890       if (s->contents == NULL)
9891         return FALSE;
9892     }
9893
9894   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9895     {
9896       if (!is_ppc64_elf (ibfd))
9897         continue;
9898
9899       s = ppc64_elf_tdata (ibfd)->got;
9900       if (s != NULL && s != htab->elf.sgot)
9901         {
9902           if (s->size == 0)
9903             s->flags |= SEC_EXCLUDE;
9904           else
9905             {
9906               s->contents = bfd_zalloc (ibfd, s->size);
9907               if (s->contents == NULL)
9908                 return FALSE;
9909             }
9910         }
9911       s = ppc64_elf_tdata (ibfd)->relgot;
9912       if (s != NULL)
9913         {
9914           if (s->size == 0)
9915             s->flags |= SEC_EXCLUDE;
9916           else
9917             {
9918               s->contents = bfd_zalloc (ibfd, s->size);
9919               if (s->contents == NULL)
9920                 return FALSE;
9921               relocs = TRUE;
9922               s->reloc_count = 0;
9923             }
9924         }
9925     }
9926
9927   if (htab->elf.dynamic_sections_created)
9928     {
9929       bfd_boolean tls_opt;
9930
9931       /* Add some entries to the .dynamic section.  We fill in the
9932          values later, in ppc64_elf_finish_dynamic_sections, but we
9933          must add the entries now so that we get the correct size for
9934          the .dynamic section.  The DT_DEBUG entry is filled in by the
9935          dynamic linker and used by the debugger.  */
9936 #define add_dynamic_entry(TAG, VAL) \
9937   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9938
9939       if (info->executable)
9940         {
9941           if (!add_dynamic_entry (DT_DEBUG, 0))
9942             return FALSE;
9943         }
9944
9945       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9946         {
9947           if (!add_dynamic_entry (DT_PLTGOT, 0)
9948               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9949               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9950               || !add_dynamic_entry (DT_JMPREL, 0)
9951               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9952             return FALSE;
9953         }
9954
9955       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9956         {
9957           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9958               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9959             return FALSE;
9960         }
9961
9962       tls_opt = (!htab->params->no_tls_get_addr_opt
9963                  && htab->tls_get_addr_fd != NULL
9964                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9965       if (tls_opt || !htab->opd_abi)
9966         {
9967           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9968             return FALSE;
9969         }
9970
9971       if (relocs)
9972         {
9973           if (!add_dynamic_entry (DT_RELA, 0)
9974               || !add_dynamic_entry (DT_RELASZ, 0)
9975               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9976             return FALSE;
9977
9978           /* If any dynamic relocs apply to a read-only section,
9979              then we need a DT_TEXTREL entry.  */
9980           if ((info->flags & DF_TEXTREL) == 0)
9981             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9982
9983           if ((info->flags & DF_TEXTREL) != 0)
9984             {
9985               if (!add_dynamic_entry (DT_TEXTREL, 0))
9986                 return FALSE;
9987             }
9988         }
9989     }
9990 #undef add_dynamic_entry
9991
9992   return TRUE;
9993 }
9994
9995 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9996
9997 static bfd_boolean
9998 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9999 {
10000   if (h->plt.plist != NULL
10001       && !h->def_regular
10002       && !h->pointer_equality_needed)
10003     return FALSE;
10004
10005   return _bfd_elf_hash_symbol (h);
10006 }
10007
10008 /* Determine the type of stub needed, if any, for a call.  */
10009
10010 static inline enum ppc_stub_type
10011 ppc_type_of_stub (asection *input_sec,
10012                   const Elf_Internal_Rela *rel,
10013                   struct ppc_link_hash_entry **hash,
10014                   struct plt_entry **plt_ent,
10015                   bfd_vma destination,
10016                   unsigned long local_off)
10017 {
10018   struct ppc_link_hash_entry *h = *hash;
10019   bfd_vma location;
10020   bfd_vma branch_offset;
10021   bfd_vma max_branch_offset;
10022   enum elf_ppc64_reloc_type r_type;
10023
10024   if (h != NULL)
10025     {
10026       struct plt_entry *ent;
10027       struct ppc_link_hash_entry *fdh = h;
10028       if (h->oh != NULL
10029           && h->oh->is_func_descriptor)
10030         {
10031           fdh = ppc_follow_link (h->oh);
10032           *hash = fdh;
10033         }
10034
10035       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10036         if (ent->addend == rel->r_addend
10037             && ent->plt.offset != (bfd_vma) -1)
10038           {
10039             *plt_ent = ent;
10040             return ppc_stub_plt_call;
10041           }
10042
10043       /* Here, we know we don't have a plt entry.  If we don't have a
10044          either a defined function descriptor or a defined entry symbol
10045          in a regular object file, then it is pointless trying to make
10046          any other type of stub.  */
10047       if (!is_static_defined (&fdh->elf)
10048           && !is_static_defined (&h->elf))
10049         return ppc_stub_none;
10050     }
10051   else if (elf_local_got_ents (input_sec->owner) != NULL)
10052     {
10053       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10054       struct plt_entry **local_plt = (struct plt_entry **)
10055         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10056       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10057
10058       if (local_plt[r_symndx] != NULL)
10059         {
10060           struct plt_entry *ent;
10061
10062           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10063             if (ent->addend == rel->r_addend
10064                 && ent->plt.offset != (bfd_vma) -1)
10065               {
10066                 *plt_ent = ent;
10067                 return ppc_stub_plt_call;
10068               }
10069         }
10070     }
10071
10072   /* Determine where the call point is.  */
10073   location = (input_sec->output_offset
10074               + input_sec->output_section->vma
10075               + rel->r_offset);
10076
10077   branch_offset = destination - location;
10078   r_type = ELF64_R_TYPE (rel->r_info);
10079
10080   /* Determine if a long branch stub is needed.  */
10081   max_branch_offset = 1 << 25;
10082   if (r_type != R_PPC64_REL24)
10083     max_branch_offset = 1 << 15;
10084
10085   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10086     /* We need a stub.  Figure out whether a long_branch or plt_branch
10087        is needed later.  */
10088     return ppc_stub_long_branch;
10089
10090   return ppc_stub_none;
10091 }
10092
10093 /* With power7 weakly ordered memory model, it is possible for ld.so
10094    to update a plt entry in one thread and have another thread see a
10095    stale zero toc entry.  To avoid this we need some sort of acquire
10096    barrier in the call stub.  One solution is to make the load of the
10097    toc word seem to appear to depend on the load of the function entry
10098    word.  Another solution is to test for r2 being zero, and branch to
10099    the appropriate glink entry if so.
10100
10101    .    fake dep barrier        compare
10102    .    ld 12,xxx(2)            ld 12,xxx(2)
10103    .    mtctr 12                mtctr 12
10104    .    xor 11,12,12            ld 2,xxx+8(2)
10105    .    add 2,2,11              cmpldi 2,0
10106    .    ld 2,xxx+8(2)           bnectr+
10107    .    bctr                    b <glink_entry>
10108
10109    The solution involving the compare turns out to be faster, so
10110    that's what we use unless the branch won't reach.  */
10111
10112 #define ALWAYS_USE_FAKE_DEP 0
10113 #define ALWAYS_EMIT_R2SAVE 0
10114
10115 #define PPC_LO(v) ((v) & 0xffff)
10116 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10117 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10118
10119 static inline unsigned int
10120 plt_stub_size (struct ppc_link_hash_table *htab,
10121                struct ppc_stub_hash_entry *stub_entry,
10122                bfd_vma off)
10123 {
10124   unsigned size = 12;
10125
10126   if (ALWAYS_EMIT_R2SAVE
10127       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10128     size += 4;
10129   if (PPC_HA (off) != 0)
10130     size += 4;
10131   if (htab->opd_abi)
10132     {
10133       size += 4;
10134       if (htab->params->plt_static_chain)
10135         size += 4;
10136       if (htab->params->plt_thread_safe)
10137         size += 8;
10138       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10139         size += 4;
10140     }
10141   if (stub_entry->h != NULL
10142       && (stub_entry->h == htab->tls_get_addr_fd
10143           || stub_entry->h == htab->tls_get_addr)
10144       && !htab->params->no_tls_get_addr_opt)
10145     size += 13 * 4;
10146   return size;
10147 }
10148
10149 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10150    then return the padding needed to do so.  */
10151 static inline unsigned int
10152 plt_stub_pad (struct ppc_link_hash_table *htab,
10153               struct ppc_stub_hash_entry *stub_entry,
10154               bfd_vma plt_off)
10155 {
10156   int stub_align = 1 << htab->params->plt_stub_align;
10157   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10158   bfd_vma stub_off = stub_entry->stub_sec->size;
10159
10160   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10161       > (stub_size & -stub_align))
10162     return stub_align - (stub_off & (stub_align - 1));
10163   return 0;
10164 }
10165
10166 /* Build a .plt call stub.  */
10167
10168 static inline bfd_byte *
10169 build_plt_stub (struct ppc_link_hash_table *htab,
10170                 struct ppc_stub_hash_entry *stub_entry,
10171                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10172 {
10173   bfd *obfd = htab->params->stub_bfd;
10174   bfd_boolean plt_load_toc = htab->opd_abi;
10175   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10176   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10177   bfd_boolean use_fake_dep = plt_thread_safe;
10178   bfd_vma cmp_branch_off = 0;
10179
10180   if (!ALWAYS_USE_FAKE_DEP
10181       && plt_load_toc
10182       && plt_thread_safe
10183       && !(stub_entry->h != NULL
10184            && (stub_entry->h == htab->tls_get_addr_fd
10185                || stub_entry->h == htab->tls_get_addr)
10186            && !htab->params->no_tls_get_addr_opt))
10187     {
10188       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10189       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10190                           / PLT_ENTRY_SIZE (htab));
10191       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10192       bfd_vma to, from;
10193
10194       if (pltindex > 32768)
10195         glinkoff += (pltindex - 32768) * 4;
10196       to = (glinkoff
10197             + htab->glink->output_offset
10198             + htab->glink->output_section->vma);
10199       from = (p - stub_entry->stub_sec->contents
10200               + 4 * (ALWAYS_EMIT_R2SAVE
10201                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10202               + 4 * (PPC_HA (offset) != 0)
10203               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10204                      != PPC_HA (offset))
10205               + 4 * (plt_static_chain != 0)
10206               + 20
10207               + stub_entry->stub_sec->output_offset
10208               + stub_entry->stub_sec->output_section->vma);
10209       cmp_branch_off = to - from;
10210       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10211     }
10212
10213   if (PPC_HA (offset) != 0)
10214     {
10215       if (r != NULL)
10216         {
10217           if (ALWAYS_EMIT_R2SAVE
10218               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10219             r[0].r_offset += 4;
10220           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10221           r[1].r_offset = r[0].r_offset + 4;
10222           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10223           r[1].r_addend = r[0].r_addend;
10224           if (plt_load_toc)
10225             {
10226               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10227                 {
10228                   r[2].r_offset = r[1].r_offset + 4;
10229                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10230                   r[2].r_addend = r[0].r_addend;
10231                 }
10232               else
10233                 {
10234                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10235                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10236                   r[2].r_addend = r[0].r_addend + 8;
10237                   if (plt_static_chain)
10238                     {
10239                       r[3].r_offset = r[2].r_offset + 4;
10240                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10241                       r[3].r_addend = r[0].r_addend + 16;
10242                     }
10243                 }
10244             }
10245         }
10246       if (ALWAYS_EMIT_R2SAVE
10247           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10248         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10249       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10250       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10251       if (plt_load_toc
10252           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10253         {
10254           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10255           offset = 0;
10256         }
10257       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10258       if (plt_load_toc)
10259         {
10260           if (use_fake_dep)
10261             {
10262               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10263               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10264             }
10265           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10266           if (plt_static_chain)
10267             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10268         }
10269     }
10270   else
10271     {
10272       if (r != NULL)
10273         {
10274           if (ALWAYS_EMIT_R2SAVE
10275               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10276             r[0].r_offset += 4;
10277           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10278           if (plt_load_toc)
10279             {
10280               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10281                 {
10282                   r[1].r_offset = r[0].r_offset + 4;
10283                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10284                   r[1].r_addend = r[0].r_addend;
10285                 }
10286               else
10287                 {
10288                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10289                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10290                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10291                   if (plt_static_chain)
10292                     {
10293                       r[2].r_offset = r[1].r_offset + 4;
10294                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10295                       r[2].r_addend = r[0].r_addend + 8;
10296                     }
10297                 }
10298             }
10299         }
10300       if (ALWAYS_EMIT_R2SAVE
10301           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10302         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10303       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10304       if (plt_load_toc
10305           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10306         {
10307           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10308           offset = 0;
10309         }
10310       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10311       if (plt_load_toc)
10312         {
10313           if (use_fake_dep)
10314             {
10315               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10316               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10317             }
10318           if (plt_static_chain)
10319             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10320           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10321         }
10322     }
10323   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10324     {
10325       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10326       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10327       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10328     }
10329   else
10330     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10331   return p;
10332 }
10333
10334 /* Build a special .plt call stub for __tls_get_addr.  */
10335
10336 #define LD_R11_0R3      0xe9630000
10337 #define LD_R12_0R3      0xe9830000
10338 #define MR_R0_R3        0x7c601b78
10339 #define CMPDI_R11_0     0x2c2b0000
10340 #define ADD_R3_R12_R13  0x7c6c6a14
10341 #define BEQLR           0x4d820020
10342 #define MR_R3_R0        0x7c030378
10343 #define STD_R11_0R1     0xf9610000
10344 #define BCTRL           0x4e800421
10345 #define LD_R11_0R1      0xe9610000
10346 #define MTLR_R11        0x7d6803a6
10347
10348 static inline bfd_byte *
10349 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10350                          struct ppc_stub_hash_entry *stub_entry,
10351                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10352 {
10353   bfd *obfd = htab->params->stub_bfd;
10354
10355   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10356   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10357   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10358   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10359   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10360   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10361   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10362   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10363   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10364
10365   if (r != NULL)
10366     r[0].r_offset += 9 * 4;
10367   p = build_plt_stub (htab, stub_entry, p, offset, r);
10368   bfd_put_32 (obfd, BCTRL, p - 4);
10369
10370   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10371   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10372   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10373   bfd_put_32 (obfd, BLR, p),                    p += 4;
10374
10375   return p;
10376 }
10377
10378 static Elf_Internal_Rela *
10379 get_relocs (asection *sec, int count)
10380 {
10381   Elf_Internal_Rela *relocs;
10382   struct bfd_elf_section_data *elfsec_data;
10383
10384   elfsec_data = elf_section_data (sec);
10385   relocs = elfsec_data->relocs;
10386   if (relocs == NULL)
10387     {
10388       bfd_size_type relsize;
10389       relsize = sec->reloc_count * sizeof (*relocs);
10390       relocs = bfd_alloc (sec->owner, relsize);
10391       if (relocs == NULL)
10392         return NULL;
10393       elfsec_data->relocs = relocs;
10394       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10395                                           sizeof (Elf_Internal_Shdr));
10396       if (elfsec_data->rela.hdr == NULL)
10397         return NULL;
10398       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10399                                         * sizeof (Elf64_External_Rela));
10400       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10401       sec->reloc_count = 0;
10402     }
10403   relocs += sec->reloc_count;
10404   sec->reloc_count += count;
10405   return relocs;
10406 }
10407
10408 static bfd_vma
10409 get_r2off (struct bfd_link_info *info,
10410            struct ppc_stub_hash_entry *stub_entry)
10411 {
10412   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10413   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10414
10415   if (r2off == 0)
10416     {
10417       /* Support linking -R objects.  Get the toc pointer from the
10418          opd entry.  */
10419       char buf[8];
10420       if (!htab->opd_abi)
10421         return r2off;
10422       asection *opd = stub_entry->h->elf.root.u.def.section;
10423       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10424
10425       if (strcmp (opd->name, ".opd") != 0
10426           || opd->reloc_count != 0)
10427         {
10428           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10429                                   stub_entry->h->elf.root.root.string);
10430           bfd_set_error (bfd_error_bad_value);
10431           return 0;
10432         }
10433       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10434         return 0;
10435       r2off = bfd_get_64 (opd->owner, buf);
10436       r2off -= elf_gp (info->output_bfd);
10437     }
10438   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10439   return r2off;
10440 }
10441
10442 static bfd_boolean
10443 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10444 {
10445   struct ppc_stub_hash_entry *stub_entry;
10446   struct ppc_branch_hash_entry *br_entry;
10447   struct bfd_link_info *info;
10448   struct ppc_link_hash_table *htab;
10449   bfd_byte *loc;
10450   bfd_byte *p;
10451   bfd_vma dest, off;
10452   int size;
10453   Elf_Internal_Rela *r;
10454   asection *plt;
10455
10456   /* Massage our args to the form they really have.  */
10457   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10458   info = in_arg;
10459
10460   htab = ppc_hash_table (info);
10461   if (htab == NULL)
10462     return FALSE;
10463
10464   /* Make a note of the offset within the stubs for this entry.  */
10465   stub_entry->stub_offset = stub_entry->stub_sec->size;
10466   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10467
10468   htab->stub_count[stub_entry->stub_type - 1] += 1;
10469   switch (stub_entry->stub_type)
10470     {
10471     case ppc_stub_long_branch:
10472     case ppc_stub_long_branch_r2off:
10473       /* Branches are relative.  This is where we are going to.  */
10474       dest = (stub_entry->target_value
10475               + stub_entry->target_section->output_offset
10476               + stub_entry->target_section->output_section->vma);
10477       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10478       off = dest;
10479
10480       /* And this is where we are coming from.  */
10481       off -= (stub_entry->stub_offset
10482               + stub_entry->stub_sec->output_offset
10483               + stub_entry->stub_sec->output_section->vma);
10484
10485       size = 4;
10486       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10487         {
10488           bfd_vma r2off = get_r2off (info, stub_entry);
10489
10490           if (r2off == 0)
10491             {
10492               htab->stub_error = TRUE;
10493               return FALSE;
10494             }
10495           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10496           loc += 4;
10497           size = 12;
10498           if (PPC_HA (r2off) != 0)
10499             {
10500               size = 16;
10501               bfd_put_32 (htab->params->stub_bfd,
10502                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10503               loc += 4;
10504             }
10505           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10506           loc += 4;
10507           off -= size - 4;
10508         }
10509       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10510
10511       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10512         {
10513           info->callbacks->einfo
10514             (_("%P: long branch stub `%s' offset overflow\n"),
10515              stub_entry->root.string);
10516           htab->stub_error = TRUE;
10517           return FALSE;
10518         }
10519
10520       if (info->emitrelocations)
10521         {
10522           r = get_relocs (stub_entry->stub_sec, 1);
10523           if (r == NULL)
10524             return FALSE;
10525           r->r_offset = loc - stub_entry->stub_sec->contents;
10526           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10527           r->r_addend = dest;
10528           if (stub_entry->h != NULL)
10529             {
10530               struct elf_link_hash_entry **hashes;
10531               unsigned long symndx;
10532               struct ppc_link_hash_entry *h;
10533
10534               hashes = elf_sym_hashes (htab->params->stub_bfd);
10535               if (hashes == NULL)
10536                 {
10537                   bfd_size_type hsize;
10538
10539                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10540                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10541                   if (hashes == NULL)
10542                     return FALSE;
10543                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10544                   htab->stub_globals = 1;
10545                 }
10546               symndx = htab->stub_globals++;
10547               h = stub_entry->h;
10548               hashes[symndx] = &h->elf;
10549               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10550               if (h->oh != NULL && h->oh->is_func)
10551                 h = ppc_follow_link (h->oh);
10552               if (h->elf.root.u.def.section != stub_entry->target_section)
10553                 /* H is an opd symbol.  The addend must be zero.  */
10554                 r->r_addend = 0;
10555               else
10556                 {
10557                   off = (h->elf.root.u.def.value
10558                          + h->elf.root.u.def.section->output_offset
10559                          + h->elf.root.u.def.section->output_section->vma);
10560                   r->r_addend -= off;
10561                 }
10562             }
10563         }
10564       break;
10565
10566     case ppc_stub_plt_branch:
10567     case ppc_stub_plt_branch_r2off:
10568       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10569                                          stub_entry->root.string + 9,
10570                                          FALSE, FALSE);
10571       if (br_entry == NULL)
10572         {
10573           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10574                                   stub_entry->root.string);
10575           htab->stub_error = TRUE;
10576           return FALSE;
10577         }
10578
10579       dest = (stub_entry->target_value
10580               + stub_entry->target_section->output_offset
10581               + stub_entry->target_section->output_section->vma);
10582       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10583         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10584
10585       bfd_put_64 (htab->brlt->owner, dest,
10586                   htab->brlt->contents + br_entry->offset);
10587
10588       if (br_entry->iter == htab->stub_iteration)
10589         {
10590           br_entry->iter = 0;
10591
10592           if (htab->relbrlt != NULL)
10593             {
10594               /* Create a reloc for the branch lookup table entry.  */
10595               Elf_Internal_Rela rela;
10596               bfd_byte *rl;
10597
10598               rela.r_offset = (br_entry->offset
10599                                + htab->brlt->output_offset
10600                                + htab->brlt->output_section->vma);
10601               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10602               rela.r_addend = dest;
10603
10604               rl = htab->relbrlt->contents;
10605               rl += (htab->relbrlt->reloc_count++
10606                      * sizeof (Elf64_External_Rela));
10607               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10608             }
10609           else if (info->emitrelocations)
10610             {
10611               r = get_relocs (htab->brlt, 1);
10612               if (r == NULL)
10613                 return FALSE;
10614               /* brlt, being SEC_LINKER_CREATED does not go through the
10615                  normal reloc processing.  Symbols and offsets are not
10616                  translated from input file to output file form, so
10617                  set up the offset per the output file.  */
10618               r->r_offset = (br_entry->offset
10619                              + htab->brlt->output_offset
10620                              + htab->brlt->output_section->vma);
10621               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10622               r->r_addend = dest;
10623             }
10624         }
10625
10626       dest = (br_entry->offset
10627               + htab->brlt->output_offset
10628               + htab->brlt->output_section->vma);
10629
10630       off = (dest
10631              - elf_gp (htab->brlt->output_section->owner)
10632              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10633
10634       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10635         {
10636           info->callbacks->einfo
10637             (_("%P: linkage table error against `%T'\n"),
10638              stub_entry->root.string);
10639           bfd_set_error (bfd_error_bad_value);
10640           htab->stub_error = TRUE;
10641           return FALSE;
10642         }
10643
10644       if (info->emitrelocations)
10645         {
10646           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10647           if (r == NULL)
10648             return FALSE;
10649           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10650           if (bfd_big_endian (info->output_bfd))
10651             r[0].r_offset += 2;
10652           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10653             r[0].r_offset += 4;
10654           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10655           r[0].r_addend = dest;
10656           if (PPC_HA (off) != 0)
10657             {
10658               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10659               r[1].r_offset = r[0].r_offset + 4;
10660               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10661               r[1].r_addend = r[0].r_addend;
10662             }
10663         }
10664
10665       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10666         {
10667           if (PPC_HA (off) != 0)
10668             {
10669               size = 16;
10670               bfd_put_32 (htab->params->stub_bfd,
10671                           ADDIS_R11_R2 | PPC_HA (off), loc);
10672               loc += 4;
10673               bfd_put_32 (htab->params->stub_bfd,
10674                           LD_R12_0R11 | PPC_LO (off), loc);
10675             }
10676           else
10677             {
10678               size = 12;
10679               bfd_put_32 (htab->params->stub_bfd,
10680                           LD_R12_0R2 | PPC_LO (off), loc);
10681             }
10682         }
10683       else
10684         {
10685           bfd_vma r2off = get_r2off (info, stub_entry);
10686
10687           if (r2off == 0 && htab->opd_abi)
10688             {
10689               htab->stub_error = TRUE;
10690               return FALSE;
10691             }
10692
10693           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10694           loc += 4;
10695           size = 16;
10696           if (PPC_HA (off) != 0)
10697             {
10698               size += 4;
10699               bfd_put_32 (htab->params->stub_bfd,
10700                           ADDIS_R11_R2 | PPC_HA (off), loc);
10701               loc += 4;
10702               bfd_put_32 (htab->params->stub_bfd,
10703                           LD_R12_0R11 | PPC_LO (off), loc);
10704             }
10705           else
10706             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10707
10708           if (PPC_HA (r2off) != 0)
10709             {
10710               size += 4;
10711               loc += 4;
10712               bfd_put_32 (htab->params->stub_bfd,
10713                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10714             }
10715           if (PPC_LO (r2off) != 0)
10716             {
10717               size += 4;
10718               loc += 4;
10719               bfd_put_32 (htab->params->stub_bfd,
10720                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10721             }
10722         }
10723       loc += 4;
10724       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10725       loc += 4;
10726       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10727       break;
10728
10729     case ppc_stub_plt_call:
10730     case ppc_stub_plt_call_r2save:
10731       if (stub_entry->h != NULL
10732           && stub_entry->h->is_func_descriptor
10733           && stub_entry->h->oh != NULL)
10734         {
10735           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10736
10737           /* If the old-ABI "dot-symbol" is undefined make it weak so
10738              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10739              FIXME: We used to define the symbol on one of the call
10740              stubs instead, which is why we test symbol section id
10741              against htab->top_id in various places.  Likely all
10742              these checks could now disappear.  */
10743           if (fh->elf.root.type == bfd_link_hash_undefined)
10744             fh->elf.root.type = bfd_link_hash_undefweak;
10745           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10746           fh->was_undefined = 0;
10747         }
10748
10749       /* Now build the stub.  */
10750       dest = stub_entry->plt_ent->plt.offset & ~1;
10751       if (dest >= (bfd_vma) -2)
10752         abort ();
10753
10754       plt = htab->elf.splt;
10755       if (!htab->elf.dynamic_sections_created
10756           || stub_entry->h == NULL
10757           || stub_entry->h->elf.dynindx == -1)
10758         plt = htab->elf.iplt;
10759
10760       dest += plt->output_offset + plt->output_section->vma;
10761
10762       if (stub_entry->h == NULL
10763           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10764         {
10765           Elf_Internal_Rela rela;
10766           bfd_byte *rl;
10767
10768           rela.r_offset = dest;
10769           if (htab->opd_abi)
10770             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10771           else
10772             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10773           rela.r_addend = (stub_entry->target_value
10774                            + stub_entry->target_section->output_offset
10775                            + stub_entry->target_section->output_section->vma);
10776
10777           rl = (htab->elf.irelplt->contents
10778                 + (htab->elf.irelplt->reloc_count++
10779                    * sizeof (Elf64_External_Rela)));
10780           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10781           stub_entry->plt_ent->plt.offset |= 1;
10782         }
10783
10784       off = (dest
10785              - elf_gp (plt->output_section->owner)
10786              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10787
10788       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10789         {
10790           info->callbacks->einfo
10791             (_("%P: linkage table error against `%T'\n"),
10792              stub_entry->h != NULL
10793              ? stub_entry->h->elf.root.root.string
10794              : "<local sym>");
10795           bfd_set_error (bfd_error_bad_value);
10796           htab->stub_error = TRUE;
10797           return FALSE;
10798         }
10799
10800       if (htab->params->plt_stub_align != 0)
10801         {
10802           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10803
10804           stub_entry->stub_sec->size += pad;
10805           stub_entry->stub_offset = stub_entry->stub_sec->size;
10806           loc += pad;
10807         }
10808
10809       r = NULL;
10810       if (info->emitrelocations)
10811         {
10812           r = get_relocs (stub_entry->stub_sec,
10813                           ((PPC_HA (off) != 0)
10814                            + (htab->opd_abi
10815                               ? 2 + (htab->params->plt_static_chain
10816                                      && PPC_HA (off + 16) == PPC_HA (off))
10817                               : 1)));
10818           if (r == NULL)
10819             return FALSE;
10820           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10821           if (bfd_big_endian (info->output_bfd))
10822             r[0].r_offset += 2;
10823           r[0].r_addend = dest;
10824         }
10825       if (stub_entry->h != NULL
10826           && (stub_entry->h == htab->tls_get_addr_fd
10827               || stub_entry->h == htab->tls_get_addr)
10828           && !htab->params->no_tls_get_addr_opt)
10829         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10830       else
10831         p = build_plt_stub (htab, stub_entry, loc, off, r);
10832       size = p - loc;
10833       break;
10834
10835     default:
10836       BFD_FAIL ();
10837       return FALSE;
10838     }
10839
10840   stub_entry->stub_sec->size += size;
10841
10842   if (htab->params->emit_stub_syms)
10843     {
10844       struct elf_link_hash_entry *h;
10845       size_t len1, len2;
10846       char *name;
10847       const char *const stub_str[] = { "long_branch",
10848                                        "long_branch_r2off",
10849                                        "plt_branch",
10850                                        "plt_branch_r2off",
10851                                        "plt_call",
10852                                        "plt_call" };
10853
10854       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10855       len2 = strlen (stub_entry->root.string);
10856       name = bfd_malloc (len1 + len2 + 2);
10857       if (name == NULL)
10858         return FALSE;
10859       memcpy (name, stub_entry->root.string, 9);
10860       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10861       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10862       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10863       if (h == NULL)
10864         return FALSE;
10865       if (h->root.type == bfd_link_hash_new)
10866         {
10867           h->root.type = bfd_link_hash_defined;
10868           h->root.u.def.section = stub_entry->stub_sec;
10869           h->root.u.def.value = stub_entry->stub_offset;
10870           h->ref_regular = 1;
10871           h->def_regular = 1;
10872           h->ref_regular_nonweak = 1;
10873           h->forced_local = 1;
10874           h->non_elf = 0;
10875         }
10876     }
10877
10878   return TRUE;
10879 }
10880
10881 /* As above, but don't actually build the stub.  Just bump offset so
10882    we know stub section sizes, and select plt_branch stubs where
10883    long_branch stubs won't do.  */
10884
10885 static bfd_boolean
10886 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10887 {
10888   struct ppc_stub_hash_entry *stub_entry;
10889   struct bfd_link_info *info;
10890   struct ppc_link_hash_table *htab;
10891   bfd_vma off;
10892   int size;
10893
10894   /* Massage our args to the form they really have.  */
10895   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10896   info = in_arg;
10897
10898   htab = ppc_hash_table (info);
10899   if (htab == NULL)
10900     return FALSE;
10901
10902   if (stub_entry->stub_type == ppc_stub_plt_call
10903       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10904     {
10905       asection *plt;
10906       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10907       if (off >= (bfd_vma) -2)
10908         abort ();
10909       plt = htab->elf.splt;
10910       if (!htab->elf.dynamic_sections_created
10911           || stub_entry->h == NULL
10912           || stub_entry->h->elf.dynindx == -1)
10913         plt = htab->elf.iplt;
10914       off += (plt->output_offset
10915               + plt->output_section->vma
10916               - elf_gp (plt->output_section->owner)
10917               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10918
10919       size = plt_stub_size (htab, stub_entry, off);
10920       if (htab->params->plt_stub_align)
10921         size += plt_stub_pad (htab, stub_entry, off);
10922       if (info->emitrelocations)
10923         {
10924           stub_entry->stub_sec->reloc_count
10925             += ((PPC_HA (off) != 0)
10926                 + (htab->opd_abi
10927                    ? 2 + (htab->params->plt_static_chain
10928                           && PPC_HA (off + 16) == PPC_HA (off))
10929                    : 1));
10930           stub_entry->stub_sec->flags |= SEC_RELOC;
10931         }
10932     }
10933   else
10934     {
10935       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10936          variants.  */
10937       bfd_vma r2off = 0;
10938       bfd_vma local_off = 0;
10939
10940       off = (stub_entry->target_value
10941              + stub_entry->target_section->output_offset
10942              + stub_entry->target_section->output_section->vma);
10943       off -= (stub_entry->stub_sec->size
10944               + stub_entry->stub_sec->output_offset
10945               + stub_entry->stub_sec->output_section->vma);
10946
10947       /* Reset the stub type from the plt variant in case we now
10948          can reach with a shorter stub.  */
10949       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10950         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10951
10952       size = 4;
10953       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10954         {
10955           r2off = get_r2off (info, stub_entry);
10956           if (r2off == 0 && htab->opd_abi)
10957             {
10958               htab->stub_error = TRUE;
10959               return FALSE;
10960             }
10961           size = 12;
10962           if (PPC_HA (r2off) != 0)
10963             size = 16;
10964           off -= size - 4;
10965         }
10966
10967       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10968
10969       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10970          Do the same for -R objects without function descriptors.  */
10971       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10972           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10973               && r2off == 0))
10974         {
10975           struct ppc_branch_hash_entry *br_entry;
10976
10977           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10978                                              stub_entry->root.string + 9,
10979                                              TRUE, FALSE);
10980           if (br_entry == NULL)
10981             {
10982               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10983                                       stub_entry->root.string);
10984               htab->stub_error = TRUE;
10985               return FALSE;
10986             }
10987
10988           if (br_entry->iter != htab->stub_iteration)
10989             {
10990               br_entry->iter = htab->stub_iteration;
10991               br_entry->offset = htab->brlt->size;
10992               htab->brlt->size += 8;
10993
10994               if (htab->relbrlt != NULL)
10995                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10996               else if (info->emitrelocations)
10997                 {
10998                   htab->brlt->reloc_count += 1;
10999                   htab->brlt->flags |= SEC_RELOC;
11000                 }
11001             }
11002
11003           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11004           off = (br_entry->offset
11005                  + htab->brlt->output_offset
11006                  + htab->brlt->output_section->vma
11007                  - elf_gp (htab->brlt->output_section->owner)
11008                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11009
11010           if (info->emitrelocations)
11011             {
11012               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11013               stub_entry->stub_sec->flags |= SEC_RELOC;
11014             }
11015
11016           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11017             {
11018               size = 12;
11019               if (PPC_HA (off) != 0)
11020                 size = 16;
11021             }
11022           else
11023             {
11024               size = 16;
11025               if (PPC_HA (off) != 0)
11026                 size += 4;
11027
11028               if (PPC_HA (r2off) != 0)
11029                 size += 4;
11030               if (PPC_LO (r2off) != 0)
11031                 size += 4;
11032             }
11033         }
11034       else if (info->emitrelocations)
11035         {
11036           stub_entry->stub_sec->reloc_count += 1;
11037           stub_entry->stub_sec->flags |= SEC_RELOC;
11038         }
11039     }
11040
11041   stub_entry->stub_sec->size += size;
11042   return TRUE;
11043 }
11044
11045 /* Set up various things so that we can make a list of input sections
11046    for each output section included in the link.  Returns -1 on error,
11047    0 when no stubs will be needed, and 1 on success.  */
11048
11049 int
11050 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11051 {
11052   bfd *input_bfd;
11053   int top_id, top_index, id;
11054   asection *section;
11055   asection **input_list;
11056   bfd_size_type amt;
11057   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11058
11059   if (htab == NULL)
11060     return -1;
11061
11062   /* Find the top input section id.  */
11063   for (input_bfd = info->input_bfds, top_id = 3;
11064        input_bfd != NULL;
11065        input_bfd = input_bfd->link_next)
11066     {
11067       for (section = input_bfd->sections;
11068            section != NULL;
11069            section = section->next)
11070         {
11071           if (top_id < section->id)
11072             top_id = section->id;
11073         }
11074     }
11075
11076   htab->top_id = top_id;
11077   amt = sizeof (struct map_stub) * (top_id + 1);
11078   htab->stub_group = bfd_zmalloc (amt);
11079   if (htab->stub_group == NULL)
11080     return -1;
11081
11082   /* Set toc_off for com, und, abs and ind sections.  */
11083   for (id = 0; id < 3; id++)
11084     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11085
11086   /* We can't use output_bfd->section_count here to find the top output
11087      section index as some sections may have been removed, and
11088      strip_excluded_output_sections doesn't renumber the indices.  */
11089   for (section = info->output_bfd->sections, top_index = 0;
11090        section != NULL;
11091        section = section->next)
11092     {
11093       if (top_index < section->index)
11094         top_index = section->index;
11095     }
11096
11097   htab->top_index = top_index;
11098   amt = sizeof (asection *) * (top_index + 1);
11099   input_list = bfd_zmalloc (amt);
11100   htab->input_list = input_list;
11101   if (input_list == NULL)
11102     return -1;
11103
11104   return 1;
11105 }
11106
11107 /* Set up for first pass at multitoc partitioning.  */
11108
11109 void
11110 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11111 {
11112   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11113
11114   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11115   htab->toc_bfd = NULL;
11116   htab->toc_first_sec = NULL;
11117 }
11118
11119 /* The linker repeatedly calls this function for each TOC input section
11120    and linker generated GOT section.  Group input bfds such that the toc
11121    within a group is less than 64k in size.  */
11122
11123 bfd_boolean
11124 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11125 {
11126   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11127   bfd_vma addr, off, limit;
11128
11129   if (htab == NULL)
11130     return FALSE;
11131
11132   if (!htab->second_toc_pass)
11133     {
11134       /* Keep track of the first .toc or .got section for this input bfd.  */
11135       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11136
11137       if (new_bfd)
11138         {
11139           htab->toc_bfd = isec->owner;
11140           htab->toc_first_sec = isec;
11141         }
11142
11143       addr = isec->output_offset + isec->output_section->vma;
11144       off = addr - htab->toc_curr;
11145       limit = 0x80008000;
11146       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11147         limit = 0x10000;
11148       if (off + isec->size > limit)
11149         {
11150           addr = (htab->toc_first_sec->output_offset
11151                   + htab->toc_first_sec->output_section->vma);
11152           htab->toc_curr = addr;
11153         }
11154
11155       /* toc_curr is the base address of this toc group.  Set elf_gp
11156          for the input section to be the offset relative to the
11157          output toc base plus 0x8000.  Making the input elf_gp an
11158          offset allows us to move the toc as a whole without
11159          recalculating input elf_gp.  */
11160       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11161       off += TOC_BASE_OFF;
11162
11163       /* Die if someone uses a linker script that doesn't keep input
11164          file .toc and .got together.  */
11165       if (new_bfd
11166           && elf_gp (isec->owner) != 0
11167           && elf_gp (isec->owner) != off)
11168         return FALSE;
11169
11170       elf_gp (isec->owner) = off;
11171       return TRUE;
11172     }
11173
11174   /* During the second pass toc_first_sec points to the start of
11175      a toc group, and toc_curr is used to track the old elf_gp.
11176      We use toc_bfd to ensure we only look at each bfd once.  */
11177   if (htab->toc_bfd == isec->owner)
11178     return TRUE;
11179   htab->toc_bfd = isec->owner;
11180
11181   if (htab->toc_first_sec == NULL
11182       || htab->toc_curr != elf_gp (isec->owner))
11183     {
11184       htab->toc_curr = elf_gp (isec->owner);
11185       htab->toc_first_sec = isec;
11186     }
11187   addr = (htab->toc_first_sec->output_offset
11188           + htab->toc_first_sec->output_section->vma);
11189   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11190   elf_gp (isec->owner) = off;
11191
11192   return TRUE;
11193 }
11194
11195 /* Called via elf_link_hash_traverse to merge GOT entries for global
11196    symbol H.  */
11197
11198 static bfd_boolean
11199 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11200 {
11201   if (h->root.type == bfd_link_hash_indirect)
11202     return TRUE;
11203
11204   merge_got_entries (&h->got.glist);
11205
11206   return TRUE;
11207 }
11208
11209 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11210    symbol H.  */
11211
11212 static bfd_boolean
11213 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11214 {
11215   struct got_entry *gent;
11216
11217   if (h->root.type == bfd_link_hash_indirect)
11218     return TRUE;
11219
11220   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11221     if (!gent->is_indirect)
11222       allocate_got (h, (struct bfd_link_info *) inf, gent);
11223   return TRUE;
11224 }
11225
11226 /* Called on the first multitoc pass after the last call to
11227    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11228    entries.  */
11229
11230 bfd_boolean
11231 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11232 {
11233   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11234   struct bfd *ibfd, *ibfd2;
11235   bfd_boolean done_something;
11236
11237   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11238
11239   if (!htab->do_multi_toc)
11240     return FALSE;
11241
11242   /* Merge global sym got entries within a toc group.  */
11243   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11244
11245   /* And tlsld_got.  */
11246   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11247     {
11248       struct got_entry *ent, *ent2;
11249
11250       if (!is_ppc64_elf (ibfd))
11251         continue;
11252
11253       ent = ppc64_tlsld_got (ibfd);
11254       if (!ent->is_indirect
11255           && ent->got.offset != (bfd_vma) -1)
11256         {
11257           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11258             {
11259               if (!is_ppc64_elf (ibfd2))
11260                 continue;
11261
11262               ent2 = ppc64_tlsld_got (ibfd2);
11263               if (!ent2->is_indirect
11264                   && ent2->got.offset != (bfd_vma) -1
11265                   && elf_gp (ibfd2) == elf_gp (ibfd))
11266                 {
11267                   ent2->is_indirect = TRUE;
11268                   ent2->got.ent = ent;
11269                 }
11270             }
11271         }
11272     }
11273
11274   /* Zap sizes of got sections.  */
11275   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11276   htab->elf.irelplt->size -= htab->got_reli_size;
11277   htab->got_reli_size = 0;
11278
11279   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11280     {
11281       asection *got, *relgot;
11282
11283       if (!is_ppc64_elf (ibfd))
11284         continue;
11285
11286       got = ppc64_elf_tdata (ibfd)->got;
11287       if (got != NULL)
11288         {
11289           got->rawsize = got->size;
11290           got->size = 0;
11291           relgot = ppc64_elf_tdata (ibfd)->relgot;
11292           relgot->rawsize = relgot->size;
11293           relgot->size = 0;
11294         }
11295     }
11296
11297   /* Now reallocate the got, local syms first.  We don't need to
11298      allocate section contents again since we never increase size.  */
11299   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11300     {
11301       struct got_entry **lgot_ents;
11302       struct got_entry **end_lgot_ents;
11303       struct plt_entry **local_plt;
11304       struct plt_entry **end_local_plt;
11305       unsigned char *lgot_masks;
11306       bfd_size_type locsymcount;
11307       Elf_Internal_Shdr *symtab_hdr;
11308       asection *s;
11309
11310       if (!is_ppc64_elf (ibfd))
11311         continue;
11312
11313       lgot_ents = elf_local_got_ents (ibfd);
11314       if (!lgot_ents)
11315         continue;
11316
11317       symtab_hdr = &elf_symtab_hdr (ibfd);
11318       locsymcount = symtab_hdr->sh_info;
11319       end_lgot_ents = lgot_ents + locsymcount;
11320       local_plt = (struct plt_entry **) end_lgot_ents;
11321       end_local_plt = local_plt + locsymcount;
11322       lgot_masks = (unsigned char *) end_local_plt;
11323       s = ppc64_elf_tdata (ibfd)->got;
11324       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11325         {
11326           struct got_entry *ent;
11327
11328           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11329             {
11330               unsigned int ent_size = 8;
11331               unsigned int rel_size = sizeof (Elf64_External_Rela);
11332
11333               ent->got.offset = s->size;
11334               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11335                 {
11336                   ent_size *= 2;
11337                   rel_size *= 2;
11338                 }
11339               s->size += ent_size;
11340               if ((*lgot_masks & PLT_IFUNC) != 0)
11341                 {
11342                   htab->elf.irelplt->size += rel_size;
11343                   htab->got_reli_size += rel_size;
11344                 }
11345               else if (info->shared)
11346                 {
11347                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11348                   srel->size += rel_size;
11349                 }
11350             }
11351         }
11352     }
11353
11354   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11355
11356   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11357     {
11358       struct got_entry *ent;
11359
11360       if (!is_ppc64_elf (ibfd))
11361         continue;
11362
11363       ent = ppc64_tlsld_got (ibfd);
11364       if (!ent->is_indirect
11365           && ent->got.offset != (bfd_vma) -1)
11366         {
11367           asection *s = ppc64_elf_tdata (ibfd)->got;
11368           ent->got.offset = s->size;
11369           s->size += 16;
11370           if (info->shared)
11371             {
11372               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11373               srel->size += sizeof (Elf64_External_Rela);
11374             }
11375         }
11376     }
11377
11378   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11379   if (!done_something)
11380     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11381       {
11382         asection *got;
11383
11384         if (!is_ppc64_elf (ibfd))
11385           continue;
11386
11387         got = ppc64_elf_tdata (ibfd)->got;
11388         if (got != NULL)
11389           {
11390             done_something = got->rawsize != got->size;
11391             if (done_something)
11392               break;
11393           }
11394       }
11395
11396   if (done_something)
11397     (*htab->params->layout_sections_again) ();
11398
11399   /* Set up for second pass over toc sections to recalculate elf_gp
11400      on input sections.  */
11401   htab->toc_bfd = NULL;
11402   htab->toc_first_sec = NULL;
11403   htab->second_toc_pass = TRUE;
11404   return done_something;
11405 }
11406
11407 /* Called after second pass of multitoc partitioning.  */
11408
11409 void
11410 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11411 {
11412   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11413
11414   /* After the second pass, toc_curr tracks the TOC offset used
11415      for code sections below in ppc64_elf_next_input_section.  */
11416   htab->toc_curr = TOC_BASE_OFF;
11417 }
11418
11419 /* No toc references were found in ISEC.  If the code in ISEC makes no
11420    calls, then there's no need to use toc adjusting stubs when branching
11421    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11422    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11423    needed, and 2 if a cyclical call-graph was found but no other reason
11424    for a stub was detected.  If called from the top level, a return of
11425    2 means the same as a return of 0.  */
11426
11427 static int
11428 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11429 {
11430   int ret;
11431
11432   /* Mark this section as checked.  */
11433   isec->call_check_done = 1;
11434
11435   /* We know none of our code bearing sections will need toc stubs.  */
11436   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11437     return 0;
11438
11439   if (isec->size == 0)
11440     return 0;
11441
11442   if (isec->output_section == NULL)
11443     return 0;
11444
11445   ret = 0;
11446   if (isec->reloc_count != 0)
11447     {
11448       Elf_Internal_Rela *relstart, *rel;
11449       Elf_Internal_Sym *local_syms;
11450       struct ppc_link_hash_table *htab;
11451
11452       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11453                                             info->keep_memory);
11454       if (relstart == NULL)
11455         return -1;
11456
11457       /* Look for branches to outside of this section.  */
11458       local_syms = NULL;
11459       htab = ppc_hash_table (info);
11460       if (htab == NULL)
11461         return -1;
11462
11463       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11464         {
11465           enum elf_ppc64_reloc_type r_type;
11466           unsigned long r_symndx;
11467           struct elf_link_hash_entry *h;
11468           struct ppc_link_hash_entry *eh;
11469           Elf_Internal_Sym *sym;
11470           asection *sym_sec;
11471           struct _opd_sec_data *opd;
11472           bfd_vma sym_value;
11473           bfd_vma dest;
11474
11475           r_type = ELF64_R_TYPE (rel->r_info);
11476           if (r_type != R_PPC64_REL24
11477               && r_type != R_PPC64_REL14
11478               && r_type != R_PPC64_REL14_BRTAKEN
11479               && r_type != R_PPC64_REL14_BRNTAKEN)
11480             continue;
11481
11482           r_symndx = ELF64_R_SYM (rel->r_info);
11483           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11484                           isec->owner))
11485             {
11486               ret = -1;
11487               break;
11488             }
11489
11490           /* Calls to dynamic lib functions go through a plt call stub
11491              that uses r2.  */
11492           eh = (struct ppc_link_hash_entry *) h;
11493           if (eh != NULL
11494               && (eh->elf.plt.plist != NULL
11495                   || (eh->oh != NULL
11496                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11497             {
11498               ret = 1;
11499               break;
11500             }
11501
11502           if (sym_sec == NULL)
11503             /* Ignore other undefined symbols.  */
11504             continue;
11505
11506           /* Assume branches to other sections not included in the
11507              link need stubs too, to cover -R and absolute syms.  */
11508           if (sym_sec->output_section == NULL)
11509             {
11510               ret = 1;
11511               break;
11512             }
11513
11514           if (h == NULL)
11515             sym_value = sym->st_value;
11516           else
11517             {
11518               if (h->root.type != bfd_link_hash_defined
11519                   && h->root.type != bfd_link_hash_defweak)
11520                 abort ();
11521               sym_value = h->root.u.def.value;
11522             }
11523           sym_value += rel->r_addend;
11524
11525           /* If this branch reloc uses an opd sym, find the code section.  */
11526           opd = get_opd_info (sym_sec);
11527           if (opd != NULL)
11528             {
11529               if (h == NULL && opd->adjust != NULL)
11530                 {
11531                   long adjust;
11532
11533                   adjust = opd->adjust[sym->st_value / 8];
11534                   if (adjust == -1)
11535                     /* Assume deleted functions won't ever be called.  */
11536                     continue;
11537                   sym_value += adjust;
11538                 }
11539
11540               dest = opd_entry_value (sym_sec, sym_value,
11541                                       &sym_sec, NULL, FALSE);
11542               if (dest == (bfd_vma) -1)
11543                 continue;
11544             }
11545           else
11546             dest = (sym_value
11547                     + sym_sec->output_offset
11548                     + sym_sec->output_section->vma);
11549
11550           /* Ignore branch to self.  */
11551           if (sym_sec == isec)
11552             continue;
11553
11554           /* If the called function uses the toc, we need a stub.  */
11555           if (sym_sec->has_toc_reloc
11556               || sym_sec->makes_toc_func_call)
11557             {
11558               ret = 1;
11559               break;
11560             }
11561
11562           /* Assume any branch that needs a long branch stub might in fact
11563              need a plt_branch stub.  A plt_branch stub uses r2.  */
11564           else if (dest - (isec->output_offset
11565                            + isec->output_section->vma
11566                            + rel->r_offset) + (1 << 25)
11567                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11568                                                              ? h->other
11569                                                              : sym->st_other))
11570             {
11571               ret = 1;
11572               break;
11573             }
11574
11575           /* If calling back to a section in the process of being
11576              tested, we can't say for sure that no toc adjusting stubs
11577              are needed, so don't return zero.  */
11578           else if (sym_sec->call_check_in_progress)
11579             ret = 2;
11580
11581           /* Branches to another section that itself doesn't have any TOC
11582              references are OK.  Recursively call ourselves to check.  */
11583           else if (!sym_sec->call_check_done)
11584             {
11585               int recur;
11586
11587               /* Mark current section as indeterminate, so that other
11588                  sections that call back to current won't be marked as
11589                  known.  */
11590               isec->call_check_in_progress = 1;
11591               recur = toc_adjusting_stub_needed (info, sym_sec);
11592               isec->call_check_in_progress = 0;
11593
11594               if (recur != 0)
11595                 {
11596                   ret = recur;
11597                   if (recur != 2)
11598                     break;
11599                 }
11600             }
11601         }
11602
11603       if (local_syms != NULL
11604           && (elf_symtab_hdr (isec->owner).contents
11605               != (unsigned char *) local_syms))
11606         free (local_syms);
11607       if (elf_section_data (isec)->relocs != relstart)
11608         free (relstart);
11609     }
11610
11611   if ((ret & 1) == 0
11612       && isec->map_head.s != NULL
11613       && (strcmp (isec->output_section->name, ".init") == 0
11614           || strcmp (isec->output_section->name, ".fini") == 0))
11615     {
11616       if (isec->map_head.s->has_toc_reloc
11617           || isec->map_head.s->makes_toc_func_call)
11618         ret = 1;
11619       else if (!isec->map_head.s->call_check_done)
11620         {
11621           int recur;
11622           isec->call_check_in_progress = 1;
11623           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11624           isec->call_check_in_progress = 0;
11625           if (recur != 0)
11626             ret = recur;
11627         }
11628     }
11629
11630   if (ret == 1)
11631     isec->makes_toc_func_call = 1;
11632
11633   return ret;
11634 }
11635
11636 /* The linker repeatedly calls this function for each input section,
11637    in the order that input sections are linked into output sections.
11638    Build lists of input sections to determine groupings between which
11639    we may insert linker stubs.  */
11640
11641 bfd_boolean
11642 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11643 {
11644   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11645
11646   if (htab == NULL)
11647     return FALSE;
11648
11649   if ((isec->output_section->flags & SEC_CODE) != 0
11650       && isec->output_section->index <= htab->top_index)
11651     {
11652       asection **list = htab->input_list + isec->output_section->index;
11653       /* Steal the link_sec pointer for our list.  */
11654 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11655       /* This happens to make the list in reverse order,
11656          which is what we want.  */
11657       PREV_SEC (isec) = *list;
11658       *list = isec;
11659     }
11660
11661   if (htab->multi_toc_needed)
11662     {
11663       /* Analyse sections that aren't already flagged as needing a
11664          valid toc pointer.  Exclude .fixup for the linux kernel.
11665          .fixup contains branches, but only back to the function that
11666          hit an exception.  */
11667       if (!(isec->has_toc_reloc
11668             || (isec->flags & SEC_CODE) == 0
11669             || strcmp (isec->name, ".fixup") == 0
11670             || isec->call_check_done))
11671         {
11672           if (toc_adjusting_stub_needed (info, isec) < 0)
11673             return FALSE;
11674         }
11675       /* Make all sections use the TOC assigned for this object file.
11676          This will be wrong for pasted sections;  We fix that in
11677          check_pasted_section().  */
11678       if (elf_gp (isec->owner) != 0)
11679         htab->toc_curr = elf_gp (isec->owner);
11680     }
11681
11682   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11683   return TRUE;
11684 }
11685
11686 /* Check that all .init and .fini sections use the same toc, if they
11687    have toc relocs.  */
11688
11689 static bfd_boolean
11690 check_pasted_section (struct bfd_link_info *info, const char *name)
11691 {
11692   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11693
11694   if (o != NULL)
11695     {
11696       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11697       bfd_vma toc_off = 0;
11698       asection *i;
11699
11700       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11701         if (i->has_toc_reloc)
11702           {
11703             if (toc_off == 0)
11704               toc_off = htab->stub_group[i->id].toc_off;
11705             else if (toc_off != htab->stub_group[i->id].toc_off)
11706               return FALSE;
11707           }
11708
11709       if (toc_off == 0)
11710         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11711           if (i->makes_toc_func_call)
11712             {
11713               toc_off = htab->stub_group[i->id].toc_off;
11714               break;
11715             }
11716
11717       /* Make sure the whole pasted function uses the same toc offset.  */
11718       if (toc_off != 0)
11719         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11720           htab->stub_group[i->id].toc_off = toc_off;
11721     }
11722   return TRUE;
11723 }
11724
11725 bfd_boolean
11726 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11727 {
11728   return (check_pasted_section (info, ".init")
11729           & check_pasted_section (info, ".fini"));
11730 }
11731
11732 /* See whether we can group stub sections together.  Grouping stub
11733    sections may result in fewer stubs.  More importantly, we need to
11734    put all .init* and .fini* stubs at the beginning of the .init or
11735    .fini output sections respectively, because glibc splits the
11736    _init and _fini functions into multiple parts.  Putting a stub in
11737    the middle of a function is not a good idea.  */
11738
11739 static void
11740 group_sections (struct ppc_link_hash_table *htab,
11741                 bfd_size_type stub_group_size,
11742                 bfd_boolean stubs_always_before_branch)
11743 {
11744   asection **list;
11745   bfd_size_type stub14_group_size;
11746   bfd_boolean suppress_size_errors;
11747
11748   suppress_size_errors = FALSE;
11749   stub14_group_size = stub_group_size;
11750   if (stub_group_size == 1)
11751     {
11752       /* Default values.  */
11753       if (stubs_always_before_branch)
11754         {
11755           stub_group_size = 0x1e00000;
11756           stub14_group_size = 0x7800;
11757         }
11758       else
11759         {
11760           stub_group_size = 0x1c00000;
11761           stub14_group_size = 0x7000;
11762         }
11763       suppress_size_errors = TRUE;
11764     }
11765
11766   list = htab->input_list + htab->top_index;
11767   do
11768     {
11769       asection *tail = *list;
11770       while (tail != NULL)
11771         {
11772           asection *curr;
11773           asection *prev;
11774           bfd_size_type total;
11775           bfd_boolean big_sec;
11776           bfd_vma curr_toc;
11777
11778           curr = tail;
11779           total = tail->size;
11780           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11781                              && ppc64_elf_section_data (tail)->has_14bit_branch
11782                              ? stub14_group_size : stub_group_size);
11783           if (big_sec && !suppress_size_errors)
11784             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11785                                      tail->owner, tail);
11786           curr_toc = htab->stub_group[tail->id].toc_off;
11787
11788           while ((prev = PREV_SEC (curr)) != NULL
11789                  && ((total += curr->output_offset - prev->output_offset)
11790                      < (ppc64_elf_section_data (prev) != NULL
11791                         && ppc64_elf_section_data (prev)->has_14bit_branch
11792                         ? stub14_group_size : stub_group_size))
11793                  && htab->stub_group[prev->id].toc_off == curr_toc)
11794             curr = prev;
11795
11796           /* OK, the size from the start of CURR to the end is less
11797              than stub_group_size and thus can be handled by one stub
11798              section.  (or the tail section is itself larger than
11799              stub_group_size, in which case we may be toast.)  We
11800              should really be keeping track of the total size of stubs
11801              added here, as stubs contribute to the final output
11802              section size.  That's a little tricky, and this way will
11803              only break if stubs added make the total size more than
11804              2^25, ie. for the default stub_group_size, if stubs total
11805              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11806           do
11807             {
11808               prev = PREV_SEC (tail);
11809               /* Set up this stub group.  */
11810               htab->stub_group[tail->id].link_sec = curr;
11811             }
11812           while (tail != curr && (tail = prev) != NULL);
11813
11814           /* But wait, there's more!  Input sections up to stub_group_size
11815              bytes before the stub section can be handled by it too.
11816              Don't do this if we have a really large section after the
11817              stubs, as adding more stubs increases the chance that
11818              branches may not reach into the stub section.  */
11819           if (!stubs_always_before_branch && !big_sec)
11820             {
11821               total = 0;
11822               while (prev != NULL
11823                      && ((total += tail->output_offset - prev->output_offset)
11824                          < (ppc64_elf_section_data (prev) != NULL
11825                             && ppc64_elf_section_data (prev)->has_14bit_branch
11826                             ? stub14_group_size : stub_group_size))
11827                      && htab->stub_group[prev->id].toc_off == curr_toc)
11828                 {
11829                   tail = prev;
11830                   prev = PREV_SEC (tail);
11831                   htab->stub_group[tail->id].link_sec = curr;
11832                 }
11833             }
11834           tail = prev;
11835         }
11836     }
11837   while (list-- != htab->input_list);
11838   free (htab->input_list);
11839 #undef PREV_SEC
11840 }
11841
11842 static const unsigned char glink_eh_frame_cie[] =
11843 {
11844   0, 0, 0, 16,                          /* length.  */
11845   0, 0, 0, 0,                           /* id.  */
11846   1,                                    /* CIE version.  */
11847   'z', 'R', 0,                          /* Augmentation string.  */
11848   4,                                    /* Code alignment.  */
11849   0x78,                                 /* Data alignment.  */
11850   65,                                   /* RA reg.  */
11851   1,                                    /* Augmentation size.  */
11852   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11853   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11854 };
11855
11856 /* Stripping output sections is normally done before dynamic section
11857    symbols have been allocated.  This function is called later, and
11858    handles cases like htab->brlt which is mapped to its own output
11859    section.  */
11860
11861 static void
11862 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11863 {
11864   if (isec->size == 0
11865       && isec->output_section->size == 0
11866       && !(isec->output_section->flags & SEC_KEEP)
11867       && !bfd_section_removed_from_list (info->output_bfd,
11868                                          isec->output_section)
11869       && elf_section_data (isec->output_section)->dynindx == 0)
11870     {
11871       isec->output_section->flags |= SEC_EXCLUDE;
11872       bfd_section_list_remove (info->output_bfd, isec->output_section);
11873       info->output_bfd->section_count--;
11874     }
11875 }
11876
11877 /* Determine and set the size of the stub section for a final link.
11878
11879    The basic idea here is to examine all the relocations looking for
11880    PC-relative calls to a target that is unreachable with a "bl"
11881    instruction.  */
11882
11883 bfd_boolean
11884 ppc64_elf_size_stubs (struct bfd_link_info *info)
11885 {
11886   bfd_size_type stub_group_size;
11887   bfd_boolean stubs_always_before_branch;
11888   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11889
11890   if (htab == NULL)
11891     return FALSE;
11892
11893   if (htab->params->plt_thread_safe == -1 && !info->executable)
11894     htab->params->plt_thread_safe = 1;
11895   if (!htab->opd_abi)
11896     htab->params->plt_thread_safe = 0;
11897   else if (htab->params->plt_thread_safe == -1)
11898     {
11899       static const char *const thread_starter[] =
11900         {
11901           "pthread_create",
11902           /* libstdc++ */
11903           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11904           /* librt */
11905           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11906           "mq_notify", "create_timer",
11907           /* libanl */
11908           "getaddrinfo_a",
11909           /* libgomp */
11910           "GOMP_parallel_start",
11911           "GOMP_parallel_loop_static_start",
11912           "GOMP_parallel_loop_dynamic_start",
11913           "GOMP_parallel_loop_guided_start",
11914           "GOMP_parallel_loop_runtime_start",
11915           "GOMP_parallel_sections_start",
11916         };
11917       unsigned i;
11918
11919       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11920         {
11921           struct elf_link_hash_entry *h;
11922           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11923                                     FALSE, FALSE, TRUE);
11924           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11925           if (htab->params->plt_thread_safe)
11926             break;
11927         }
11928     }
11929   stubs_always_before_branch = htab->params->group_size < 0;
11930   if (htab->params->group_size < 0)
11931     stub_group_size = -htab->params->group_size;
11932   else
11933     stub_group_size = htab->params->group_size;
11934
11935   group_sections (htab, stub_group_size, stubs_always_before_branch);
11936
11937   while (1)
11938     {
11939       bfd *input_bfd;
11940       unsigned int bfd_indx;
11941       asection *stub_sec;
11942
11943       htab->stub_iteration += 1;
11944
11945       for (input_bfd = info->input_bfds, bfd_indx = 0;
11946            input_bfd != NULL;
11947            input_bfd = input_bfd->link_next, bfd_indx++)
11948         {
11949           Elf_Internal_Shdr *symtab_hdr;
11950           asection *section;
11951           Elf_Internal_Sym *local_syms = NULL;
11952
11953           if (!is_ppc64_elf (input_bfd))
11954             continue;
11955
11956           /* We'll need the symbol table in a second.  */
11957           symtab_hdr = &elf_symtab_hdr (input_bfd);
11958           if (symtab_hdr->sh_info == 0)
11959             continue;
11960
11961           /* Walk over each section attached to the input bfd.  */
11962           for (section = input_bfd->sections;
11963                section != NULL;
11964                section = section->next)
11965             {
11966               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11967
11968               /* If there aren't any relocs, then there's nothing more
11969                  to do.  */
11970               if ((section->flags & SEC_RELOC) == 0
11971                   || (section->flags & SEC_ALLOC) == 0
11972                   || (section->flags & SEC_LOAD) == 0
11973                   || (section->flags & SEC_CODE) == 0
11974                   || section->reloc_count == 0)
11975                 continue;
11976
11977               /* If this section is a link-once section that will be
11978                  discarded, then don't create any stubs.  */
11979               if (section->output_section == NULL
11980                   || section->output_section->owner != info->output_bfd)
11981                 continue;
11982
11983               /* Get the relocs.  */
11984               internal_relocs
11985                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11986                                              info->keep_memory);
11987               if (internal_relocs == NULL)
11988                 goto error_ret_free_local;
11989
11990               /* Now examine each relocation.  */
11991               irela = internal_relocs;
11992               irelaend = irela + section->reloc_count;
11993               for (; irela < irelaend; irela++)
11994                 {
11995                   enum elf_ppc64_reloc_type r_type;
11996                   unsigned int r_indx;
11997                   enum ppc_stub_type stub_type;
11998                   struct ppc_stub_hash_entry *stub_entry;
11999                   asection *sym_sec, *code_sec;
12000                   bfd_vma sym_value, code_value;
12001                   bfd_vma destination;
12002                   unsigned long local_off;
12003                   bfd_boolean ok_dest;
12004                   struct ppc_link_hash_entry *hash;
12005                   struct ppc_link_hash_entry *fdh;
12006                   struct elf_link_hash_entry *h;
12007                   Elf_Internal_Sym *sym;
12008                   char *stub_name;
12009                   const asection *id_sec;
12010                   struct _opd_sec_data *opd;
12011                   struct plt_entry *plt_ent;
12012
12013                   r_type = ELF64_R_TYPE (irela->r_info);
12014                   r_indx = ELF64_R_SYM (irela->r_info);
12015
12016                   if (r_type >= R_PPC64_max)
12017                     {
12018                       bfd_set_error (bfd_error_bad_value);
12019                       goto error_ret_free_internal;
12020                     }
12021
12022                   /* Only look for stubs on branch instructions.  */
12023                   if (r_type != R_PPC64_REL24
12024                       && r_type != R_PPC64_REL14
12025                       && r_type != R_PPC64_REL14_BRTAKEN
12026                       && r_type != R_PPC64_REL14_BRNTAKEN)
12027                     continue;
12028
12029                   /* Now determine the call target, its name, value,
12030                      section.  */
12031                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12032                                   r_indx, input_bfd))
12033                     goto error_ret_free_internal;
12034                   hash = (struct ppc_link_hash_entry *) h;
12035
12036                   ok_dest = FALSE;
12037                   fdh = NULL;
12038                   sym_value = 0;
12039                   if (hash == NULL)
12040                     {
12041                       sym_value = sym->st_value;
12042                       ok_dest = TRUE;
12043                     }
12044                   else if (hash->elf.root.type == bfd_link_hash_defined
12045                            || hash->elf.root.type == bfd_link_hash_defweak)
12046                     {
12047                       sym_value = hash->elf.root.u.def.value;
12048                       if (sym_sec->output_section != NULL)
12049                         ok_dest = TRUE;
12050                     }
12051                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12052                            || hash->elf.root.type == bfd_link_hash_undefined)
12053                     {
12054                       /* Recognise an old ABI func code entry sym, and
12055                          use the func descriptor sym instead if it is
12056                          defined.  */
12057                       if (hash->elf.root.root.string[0] == '.'
12058                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12059                         {
12060                           if (fdh->elf.root.type == bfd_link_hash_defined
12061                               || fdh->elf.root.type == bfd_link_hash_defweak)
12062                             {
12063                               sym_sec = fdh->elf.root.u.def.section;
12064                               sym_value = fdh->elf.root.u.def.value;
12065                               if (sym_sec->output_section != NULL)
12066                                 ok_dest = TRUE;
12067                             }
12068                           else
12069                             fdh = NULL;
12070                         }
12071                     }
12072                   else
12073                     {
12074                       bfd_set_error (bfd_error_bad_value);
12075                       goto error_ret_free_internal;
12076                     }
12077
12078                   destination = 0;
12079                   local_off = 0;
12080                   if (ok_dest)
12081                     {
12082                       sym_value += irela->r_addend;
12083                       destination = (sym_value
12084                                      + sym_sec->output_offset
12085                                      + sym_sec->output_section->vma);
12086                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12087                                                             ? hash->elf.other
12088                                                             : sym->st_other);
12089                     }
12090
12091                   code_sec = sym_sec;
12092                   code_value = sym_value;
12093                   opd = get_opd_info (sym_sec);
12094                   if (opd != NULL)
12095                     {
12096                       bfd_vma dest;
12097
12098                       if (hash == NULL && opd->adjust != NULL)
12099                         {
12100                           long adjust = opd->adjust[sym_value / 8];
12101                           if (adjust == -1)
12102                             continue;
12103                           code_value += adjust;
12104                           sym_value += adjust;
12105                         }
12106                       dest = opd_entry_value (sym_sec, sym_value,
12107                                               &code_sec, &code_value, FALSE);
12108                       if (dest != (bfd_vma) -1)
12109                         {
12110                           destination = dest;
12111                           if (fdh != NULL)
12112                             {
12113                               /* Fixup old ABI sym to point at code
12114                                  entry.  */
12115                               hash->elf.root.type = bfd_link_hash_defweak;
12116                               hash->elf.root.u.def.section = code_sec;
12117                               hash->elf.root.u.def.value = code_value;
12118                             }
12119                         }
12120                     }
12121
12122                   /* Determine what (if any) linker stub is needed.  */
12123                   plt_ent = NULL;
12124                   stub_type = ppc_type_of_stub (section, irela, &hash,
12125                                                 &plt_ent, destination,
12126                                                 local_off);
12127
12128                   if (stub_type != ppc_stub_plt_call)
12129                     {
12130                       /* Check whether we need a TOC adjusting stub.
12131                          Since the linker pastes together pieces from
12132                          different object files when creating the
12133                          _init and _fini functions, it may be that a
12134                          call to what looks like a local sym is in
12135                          fact a call needing a TOC adjustment.  */
12136                       if (code_sec != NULL
12137                           && code_sec->output_section != NULL
12138                           && (htab->stub_group[code_sec->id].toc_off
12139                               != htab->stub_group[section->id].toc_off)
12140                           && (code_sec->has_toc_reloc
12141                               || code_sec->makes_toc_func_call))
12142                         stub_type = ppc_stub_long_branch_r2off;
12143                     }
12144
12145                   if (stub_type == ppc_stub_none)
12146                     continue;
12147
12148                   /* __tls_get_addr calls might be eliminated.  */
12149                   if (stub_type != ppc_stub_plt_call
12150                       && hash != NULL
12151                       && (hash == htab->tls_get_addr
12152                           || hash == htab->tls_get_addr_fd)
12153                       && section->has_tls_reloc
12154                       && irela != internal_relocs)
12155                     {
12156                       /* Get tls info.  */
12157                       unsigned char *tls_mask;
12158
12159                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12160                                          irela - 1, input_bfd))
12161                         goto error_ret_free_internal;
12162                       if (*tls_mask != 0)
12163                         continue;
12164                     }
12165
12166                   if (stub_type == ppc_stub_plt_call
12167                       && irela + 1 < irelaend
12168                       && irela[1].r_offset == irela->r_offset + 4
12169                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12170                     {
12171                       if (!tocsave_find (htab, INSERT,
12172                                          &local_syms, irela + 1, input_bfd))
12173                         goto error_ret_free_internal;
12174                     }
12175                   else if (stub_type == ppc_stub_plt_call)
12176                     stub_type = ppc_stub_plt_call_r2save;
12177
12178                   /* Support for grouping stub sections.  */
12179                   id_sec = htab->stub_group[section->id].link_sec;
12180
12181                   /* Get the name of this stub.  */
12182                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12183                   if (!stub_name)
12184                     goto error_ret_free_internal;
12185
12186                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12187                                                      stub_name, FALSE, FALSE);
12188                   if (stub_entry != NULL)
12189                     {
12190                       /* The proper stub has already been created.  */
12191                       free (stub_name);
12192                       if (stub_type == ppc_stub_plt_call_r2save)
12193                         stub_entry->stub_type = stub_type;
12194                       continue;
12195                     }
12196
12197                   stub_entry = ppc_add_stub (stub_name, section, info);
12198                   if (stub_entry == NULL)
12199                     {
12200                       free (stub_name);
12201                     error_ret_free_internal:
12202                       if (elf_section_data (section)->relocs == NULL)
12203                         free (internal_relocs);
12204                     error_ret_free_local:
12205                       if (local_syms != NULL
12206                           && (symtab_hdr->contents
12207                               != (unsigned char *) local_syms))
12208                         free (local_syms);
12209                       return FALSE;
12210                     }
12211
12212                   stub_entry->stub_type = stub_type;
12213                   if (stub_type != ppc_stub_plt_call
12214                       && stub_type != ppc_stub_plt_call_r2save)
12215                     {
12216                       stub_entry->target_value = code_value;
12217                       stub_entry->target_section = code_sec;
12218                     }
12219                   else
12220                     {
12221                       stub_entry->target_value = sym_value;
12222                       stub_entry->target_section = sym_sec;
12223                     }
12224                   stub_entry->h = hash;
12225                   stub_entry->plt_ent = plt_ent;
12226                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12227
12228                   if (stub_entry->h != NULL)
12229                     htab->stub_globals += 1;
12230                 }
12231
12232               /* We're done with the internal relocs, free them.  */
12233               if (elf_section_data (section)->relocs != internal_relocs)
12234                 free (internal_relocs);
12235             }
12236
12237           if (local_syms != NULL
12238               && symtab_hdr->contents != (unsigned char *) local_syms)
12239             {
12240               if (!info->keep_memory)
12241                 free (local_syms);
12242               else
12243                 symtab_hdr->contents = (unsigned char *) local_syms;
12244             }
12245         }
12246
12247       /* We may have added some stubs.  Find out the new size of the
12248          stub sections.  */
12249       for (stub_sec = htab->params->stub_bfd->sections;
12250            stub_sec != NULL;
12251            stub_sec = stub_sec->next)
12252         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12253           {
12254             stub_sec->rawsize = stub_sec->size;
12255             stub_sec->size = 0;
12256             stub_sec->reloc_count = 0;
12257             stub_sec->flags &= ~SEC_RELOC;
12258           }
12259
12260       htab->brlt->size = 0;
12261       htab->brlt->reloc_count = 0;
12262       htab->brlt->flags &= ~SEC_RELOC;
12263       if (htab->relbrlt != NULL)
12264         htab->relbrlt->size = 0;
12265
12266       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12267
12268       if (info->emitrelocations
12269           && htab->glink != NULL && htab->glink->size != 0)
12270         {
12271           htab->glink->reloc_count = 1;
12272           htab->glink->flags |= SEC_RELOC;
12273         }
12274
12275       if (htab->glink_eh_frame != NULL
12276           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12277           && htab->glink_eh_frame->output_section->size != 0)
12278         {
12279           size_t size = 0, align;
12280
12281           for (stub_sec = htab->params->stub_bfd->sections;
12282                stub_sec != NULL;
12283                stub_sec = stub_sec->next)
12284             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12285               size += 20;
12286           if (htab->glink != NULL && htab->glink->size != 0)
12287             size += 24;
12288           if (size != 0)
12289             size += sizeof (glink_eh_frame_cie);
12290           align = 1;
12291           align <<= htab->glink_eh_frame->output_section->alignment_power;
12292           align -= 1;
12293           size = (size + align) & ~align;
12294           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12295           htab->glink_eh_frame->size = size;
12296         }
12297
12298       if (htab->params->plt_stub_align != 0)
12299         for (stub_sec = htab->params->stub_bfd->sections;
12300              stub_sec != NULL;
12301              stub_sec = stub_sec->next)
12302           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12303             stub_sec->size = ((stub_sec->size
12304                                + (1 << htab->params->plt_stub_align) - 1)
12305                               & (-1 << htab->params->plt_stub_align));
12306
12307       for (stub_sec = htab->params->stub_bfd->sections;
12308            stub_sec != NULL;
12309            stub_sec = stub_sec->next)
12310         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12311             && stub_sec->rawsize != stub_sec->size)
12312           break;
12313
12314       /* Exit from this loop when no stubs have been added, and no stubs
12315          have changed size.  */
12316       if (stub_sec == NULL
12317           && (htab->glink_eh_frame == NULL
12318               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12319         break;
12320
12321       /* Ask the linker to do its stuff.  */
12322       (*htab->params->layout_sections_again) ();
12323     }
12324
12325   maybe_strip_output (info, htab->brlt);
12326   if (htab->glink_eh_frame != NULL)
12327     maybe_strip_output (info, htab->glink_eh_frame);
12328
12329   return TRUE;
12330 }
12331
12332 /* Called after we have determined section placement.  If sections
12333    move, we'll be called again.  Provide a value for TOCstart.  */
12334
12335 bfd_vma
12336 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12337 {
12338   asection *s;
12339   bfd_vma TOCstart;
12340
12341   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12342      order.  The TOC starts where the first of these sections starts.  */
12343   s = bfd_get_section_by_name (obfd, ".got");
12344   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12345     s = bfd_get_section_by_name (obfd, ".toc");
12346   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12347     s = bfd_get_section_by_name (obfd, ".tocbss");
12348   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12349     s = bfd_get_section_by_name (obfd, ".plt");
12350   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12351     {
12352       /* This may happen for
12353          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12354          .toc directive
12355          o  bad linker script
12356          o --gc-sections and empty TOC sections
12357
12358          FIXME: Warn user?  */
12359
12360       /* Look for a likely section.  We probably won't even be
12361          using TOCstart.  */
12362       for (s = obfd->sections; s != NULL; s = s->next)
12363         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12364                          | SEC_EXCLUDE))
12365             == (SEC_ALLOC | SEC_SMALL_DATA))
12366           break;
12367       if (s == NULL)
12368         for (s = obfd->sections; s != NULL; s = s->next)
12369           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12370               == (SEC_ALLOC | SEC_SMALL_DATA))
12371             break;
12372       if (s == NULL)
12373         for (s = obfd->sections; s != NULL; s = s->next)
12374           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12375               == SEC_ALLOC)
12376             break;
12377       if (s == NULL)
12378         for (s = obfd->sections; s != NULL; s = s->next)
12379           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12380             break;
12381     }
12382
12383   TOCstart = 0;
12384   if (s != NULL)
12385     TOCstart = s->output_section->vma + s->output_offset;
12386
12387   _bfd_set_gp_value (obfd, TOCstart);
12388
12389   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12390     {
12391       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12392
12393       if (htab != NULL
12394           && htab->elf.hgot != NULL)
12395         {
12396           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12397           htab->elf.hgot->root.u.def.section = s;
12398         }
12399     }
12400   return TOCstart;
12401 }
12402
12403 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12404    write out any global entry stubs.  */
12405
12406 static bfd_boolean
12407 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12408 {
12409   struct bfd_link_info *info;
12410   struct ppc_link_hash_table *htab;
12411   struct plt_entry *pent;
12412   asection *s;
12413
12414   if (h->root.type == bfd_link_hash_indirect)
12415     return TRUE;
12416
12417   if (!h->pointer_equality_needed)
12418     return TRUE;
12419
12420   if (h->def_regular)
12421     return TRUE;
12422
12423   info = inf;
12424   htab = ppc_hash_table (info);
12425   if (htab == NULL)
12426     return FALSE;
12427
12428   s = htab->glink;
12429   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12430     if (pent->plt.offset != (bfd_vma) -1
12431         && pent->addend == 0)
12432       {
12433         bfd_byte *p;
12434         asection *plt;
12435         bfd_vma off;
12436
12437         p = s->contents + h->root.u.def.value;
12438         plt = htab->elf.splt;
12439         if (!htab->elf.dynamic_sections_created
12440             || h->dynindx == -1)
12441           plt = htab->elf.iplt;
12442         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12443         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12444
12445         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12446           {
12447             info->callbacks->einfo
12448               (_("%P: linkage table error against `%T'\n"),
12449                h->root.root.string);
12450             bfd_set_error (bfd_error_bad_value);
12451             htab->stub_error = TRUE;
12452           }
12453
12454         if (PPC_HA (off) != 0)
12455           {
12456             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12457             p += 4;
12458           }
12459         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12460         p += 4;
12461         bfd_put_32 (s->owner, MTCTR_R12, p);
12462         p += 4;
12463         bfd_put_32 (s->owner, BCTR, p);
12464         break;
12465       }
12466   return TRUE;
12467 }
12468
12469 /* Build all the stubs associated with the current output file.
12470    The stubs are kept in a hash table attached to the main linker
12471    hash table.  This function is called via gldelf64ppc_finish.  */
12472
12473 bfd_boolean
12474 ppc64_elf_build_stubs (struct bfd_link_info *info,
12475                        char **stats)
12476 {
12477   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12478   asection *stub_sec;
12479   bfd_byte *p;
12480   int stub_sec_count = 0;
12481
12482   if (htab == NULL)
12483     return FALSE;
12484
12485   /* Allocate memory to hold the linker stubs.  */
12486   for (stub_sec = htab->params->stub_bfd->sections;
12487        stub_sec != NULL;
12488        stub_sec = stub_sec->next)
12489     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12490         && stub_sec->size != 0)
12491       {
12492         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12493         if (stub_sec->contents == NULL)
12494           return FALSE;
12495         /* We want to check that built size is the same as calculated
12496            size.  rawsize is a convenient location to use.  */
12497         stub_sec->rawsize = stub_sec->size;
12498         stub_sec->size = 0;
12499       }
12500
12501   if (htab->glink != NULL && htab->glink->size != 0)
12502     {
12503       unsigned int indx;
12504       bfd_vma plt0;
12505
12506       /* Build the .glink plt call stub.  */
12507       if (htab->params->emit_stub_syms)
12508         {
12509           struct elf_link_hash_entry *h;
12510           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12511                                     TRUE, FALSE, FALSE);
12512           if (h == NULL)
12513             return FALSE;
12514           if (h->root.type == bfd_link_hash_new)
12515             {
12516               h->root.type = bfd_link_hash_defined;
12517               h->root.u.def.section = htab->glink;
12518               h->root.u.def.value = 8;
12519               h->ref_regular = 1;
12520               h->def_regular = 1;
12521               h->ref_regular_nonweak = 1;
12522               h->forced_local = 1;
12523               h->non_elf = 0;
12524             }
12525         }
12526       plt0 = (htab->elf.splt->output_section->vma
12527               + htab->elf.splt->output_offset
12528               - 16);
12529       if (info->emitrelocations)
12530         {
12531           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12532           if (r == NULL)
12533             return FALSE;
12534           r->r_offset = (htab->glink->output_offset
12535                          + htab->glink->output_section->vma);
12536           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12537           r->r_addend = plt0;
12538         }
12539       p = htab->glink->contents;
12540       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12541       bfd_put_64 (htab->glink->owner, plt0, p);
12542       p += 8;
12543       if (htab->opd_abi)
12544         {
12545           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12546           p += 4;
12547           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12548           p += 4;
12549           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12550           p += 4;
12551           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12552           p += 4;
12553           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12554           p += 4;
12555           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12556           p += 4;
12557           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12558           p += 4;
12559           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12560           p += 4;
12561           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12562           p += 4;
12563           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12564           p += 4;
12565         }
12566       else
12567         {
12568           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12569           p += 4;
12570           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12571           p += 4;
12572           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12573           p += 4;
12574           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12575           p += 4;
12576           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12577           p += 4;
12578           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12579           p += 4;
12580           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12581           p += 4;
12582           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12583           p += 4;
12584           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12585           p += 4;
12586           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12587           p += 4;
12588           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12589           p += 4;
12590           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12591           p += 4;
12592         }
12593       bfd_put_32 (htab->glink->owner, BCTR, p);
12594       p += 4;
12595       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12596         {
12597           bfd_put_32 (htab->glink->owner, NOP, p);
12598           p += 4;
12599         }
12600
12601       /* Build the .glink lazy link call stubs.  */
12602       indx = 0;
12603       while (p < htab->glink->contents + htab->glink->rawsize)
12604         {
12605           if (htab->opd_abi)
12606             {
12607               if (indx < 0x8000)
12608                 {
12609                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12610                   p += 4;
12611                 }
12612               else
12613                 {
12614                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12615                   p += 4;
12616                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12617                               p);
12618                   p += 4;
12619                 }
12620             }
12621           bfd_put_32 (htab->glink->owner,
12622                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12623           indx++;
12624           p += 4;
12625         }
12626
12627       /* Build .glink global entry stubs.  */
12628       if (htab->glink->size > htab->glink->rawsize)
12629         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12630     }
12631
12632   if (htab->brlt->size != 0)
12633     {
12634       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12635                                          htab->brlt->size);
12636       if (htab->brlt->contents == NULL)
12637         return FALSE;
12638     }
12639   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12640     {
12641       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12642                                             htab->relbrlt->size);
12643       if (htab->relbrlt->contents == NULL)
12644         return FALSE;
12645     }
12646
12647   if (htab->glink_eh_frame != NULL
12648       && htab->glink_eh_frame->size != 0)
12649     {
12650       bfd_vma val;
12651       bfd_byte *last_fde;
12652       size_t last_fde_len, size, align, pad;
12653
12654       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12655       if (p == NULL)
12656         return FALSE;
12657       htab->glink_eh_frame->contents = p;
12658       last_fde = p;
12659
12660       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12661
12662       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12663       /* CIE length (rewrite in case little-endian).  */
12664       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12665       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12666       p += sizeof (glink_eh_frame_cie);
12667
12668       for (stub_sec = htab->params->stub_bfd->sections;
12669            stub_sec != NULL;
12670            stub_sec = stub_sec->next)
12671         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12672           {
12673             last_fde = p;
12674             last_fde_len = 16;
12675             /* FDE length.  */
12676             bfd_put_32 (htab->elf.dynobj, 16, p);
12677             p += 4;
12678             /* CIE pointer.  */
12679             val = p - htab->glink_eh_frame->contents;
12680             bfd_put_32 (htab->elf.dynobj, val, p);
12681             p += 4;
12682             /* Offset to stub section.  */
12683             val = (stub_sec->output_section->vma
12684                    + stub_sec->output_offset);
12685             val -= (htab->glink_eh_frame->output_section->vma
12686                     + htab->glink_eh_frame->output_offset);
12687             val -= p - htab->glink_eh_frame->contents;
12688             if (val + 0x80000000 > 0xffffffff)
12689               {
12690                 info->callbacks->einfo
12691                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12692                    stub_sec->name);
12693                 return FALSE;
12694               }
12695             bfd_put_32 (htab->elf.dynobj, val, p);
12696             p += 4;
12697             /* stub section size.  */
12698             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12699             p += 4;
12700             /* Augmentation.  */
12701             p += 1;
12702             /* Pad.  */
12703             p += 3;
12704           }
12705       if (htab->glink != NULL && htab->glink->size != 0)
12706         {
12707           last_fde = p;
12708           last_fde_len = 20;
12709           /* FDE length.  */
12710           bfd_put_32 (htab->elf.dynobj, 20, p);
12711           p += 4;
12712           /* CIE pointer.  */
12713           val = p - htab->glink_eh_frame->contents;
12714           bfd_put_32 (htab->elf.dynobj, val, p);
12715           p += 4;
12716           /* Offset to .glink.  */
12717           val = (htab->glink->output_section->vma
12718                  + htab->glink->output_offset
12719                  + 8);
12720           val -= (htab->glink_eh_frame->output_section->vma
12721                   + htab->glink_eh_frame->output_offset);
12722           val -= p - htab->glink_eh_frame->contents;
12723           if (val + 0x80000000 > 0xffffffff)
12724             {
12725               info->callbacks->einfo
12726                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12727                  htab->glink->name);
12728               return FALSE;
12729             }
12730           bfd_put_32 (htab->elf.dynobj, val, p);
12731           p += 4;
12732           /* .glink size.  */
12733           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12734           p += 4;
12735           /* Augmentation.  */
12736           p += 1;
12737
12738           *p++ = DW_CFA_advance_loc + 1;
12739           *p++ = DW_CFA_register;
12740           *p++ = 65;
12741           *p++ = 12;
12742           *p++ = DW_CFA_advance_loc + 4;
12743           *p++ = DW_CFA_restore_extended;
12744           *p++ = 65;
12745         }
12746       /* Subsume any padding into the last FDE if user .eh_frame
12747          sections are aligned more than glink_eh_frame.  Otherwise any
12748          zero padding will be seen as a terminator.  */
12749       size = p - htab->glink_eh_frame->contents;
12750       align = 1;
12751       align <<= htab->glink_eh_frame->output_section->alignment_power;
12752       align -= 1;
12753       pad = ((size + align) & ~align) - size;
12754       htab->glink_eh_frame->size = size + pad;
12755       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12756     }
12757
12758   /* Build the stubs as directed by the stub hash table.  */
12759   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12760
12761   if (htab->relbrlt != NULL)
12762     htab->relbrlt->reloc_count = 0;
12763
12764   if (htab->params->plt_stub_align != 0)
12765     for (stub_sec = htab->params->stub_bfd->sections;
12766          stub_sec != NULL;
12767          stub_sec = stub_sec->next)
12768       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12769         stub_sec->size = ((stub_sec->size
12770                            + (1 << htab->params->plt_stub_align) - 1)
12771                           & (-1 << htab->params->plt_stub_align));
12772
12773   for (stub_sec = htab->params->stub_bfd->sections;
12774        stub_sec != NULL;
12775        stub_sec = stub_sec->next)
12776     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12777       {
12778         stub_sec_count += 1;
12779         if (stub_sec->rawsize != stub_sec->size)
12780           break;
12781       }
12782
12783   if (stub_sec != NULL
12784       || (htab->glink_eh_frame != NULL
12785           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12786     {
12787       htab->stub_error = TRUE;
12788       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12789     }
12790
12791   if (htab->stub_error)
12792     return FALSE;
12793
12794   if (stats != NULL)
12795     {
12796       *stats = bfd_malloc (500);
12797       if (*stats == NULL)
12798         return FALSE;
12799
12800       sprintf (*stats, _("linker stubs in %u group%s\n"
12801                          "  branch       %lu\n"
12802                          "  toc adjust   %lu\n"
12803                          "  long branch  %lu\n"
12804                          "  long toc adj %lu\n"
12805                          "  plt call     %lu\n"
12806                          "  plt call toc %lu"),
12807                stub_sec_count,
12808                stub_sec_count == 1 ? "" : "s",
12809                htab->stub_count[ppc_stub_long_branch - 1],
12810                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12811                htab->stub_count[ppc_stub_plt_branch - 1],
12812                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12813                htab->stub_count[ppc_stub_plt_call - 1],
12814                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12815     }
12816   return TRUE;
12817 }
12818
12819 /* This function undoes the changes made by add_symbol_adjust.  */
12820
12821 static bfd_boolean
12822 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12823 {
12824   struct ppc_link_hash_entry *eh;
12825
12826   if (h->root.type == bfd_link_hash_indirect)
12827     return TRUE;
12828
12829   eh = (struct ppc_link_hash_entry *) h;
12830   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12831     return TRUE;
12832
12833   eh->elf.root.type = bfd_link_hash_undefined;
12834   return TRUE;
12835 }
12836
12837 void
12838 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12839 {
12840   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12841
12842   if (htab != NULL)
12843     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12844 }
12845
12846 /* What to do when ld finds relocations against symbols defined in
12847    discarded sections.  */
12848
12849 static unsigned int
12850 ppc64_elf_action_discarded (asection *sec)
12851 {
12852   if (strcmp (".opd", sec->name) == 0)
12853     return 0;
12854
12855   if (strcmp (".toc", sec->name) == 0)
12856     return 0;
12857
12858   if (strcmp (".toc1", sec->name) == 0)
12859     return 0;
12860
12861   return _bfd_elf_default_action_discarded (sec);
12862 }
12863
12864 /* The RELOCATE_SECTION function is called by the ELF backend linker
12865    to handle the relocations for a section.
12866
12867    The relocs are always passed as Rela structures; if the section
12868    actually uses Rel structures, the r_addend field will always be
12869    zero.
12870
12871    This function is responsible for adjust the section contents as
12872    necessary, and (if using Rela relocs and generating a
12873    relocatable output file) adjusting the reloc addend as
12874    necessary.
12875
12876    This function does not have to worry about setting the reloc
12877    address or the reloc symbol index.
12878
12879    LOCAL_SYMS is a pointer to the swapped in local symbols.
12880
12881    LOCAL_SECTIONS is an array giving the section in the input file
12882    corresponding to the st_shndx field of each local symbol.
12883
12884    The global hash table entry for the global symbols can be found
12885    via elf_sym_hashes (input_bfd).
12886
12887    When generating relocatable output, this function must handle
12888    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12889    going to be the section symbol corresponding to the output
12890    section, which means that the addend must be adjusted
12891    accordingly.  */
12892
12893 static bfd_boolean
12894 ppc64_elf_relocate_section (bfd *output_bfd,
12895                             struct bfd_link_info *info,
12896                             bfd *input_bfd,
12897                             asection *input_section,
12898                             bfd_byte *contents,
12899                             Elf_Internal_Rela *relocs,
12900                             Elf_Internal_Sym *local_syms,
12901                             asection **local_sections)
12902 {
12903   struct ppc_link_hash_table *htab;
12904   Elf_Internal_Shdr *symtab_hdr;
12905   struct elf_link_hash_entry **sym_hashes;
12906   Elf_Internal_Rela *rel;
12907   Elf_Internal_Rela *relend;
12908   Elf_Internal_Rela outrel;
12909   bfd_byte *loc;
12910   struct got_entry **local_got_ents;
12911   bfd_vma TOCstart;
12912   bfd_boolean ret = TRUE;
12913   bfd_boolean is_opd;
12914   /* Assume 'at' branch hints.  */
12915   bfd_boolean is_isa_v2 = TRUE;
12916   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12917
12918   /* Initialize howto table if needed.  */
12919   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12920     ppc_howto_init ();
12921
12922   htab = ppc_hash_table (info);
12923   if (htab == NULL)
12924     return FALSE;
12925
12926   /* Don't relocate stub sections.  */
12927   if (input_section->owner == htab->params->stub_bfd)
12928     return TRUE;
12929
12930   BFD_ASSERT (is_ppc64_elf (input_bfd));
12931
12932   local_got_ents = elf_local_got_ents (input_bfd);
12933   TOCstart = elf_gp (output_bfd);
12934   symtab_hdr = &elf_symtab_hdr (input_bfd);
12935   sym_hashes = elf_sym_hashes (input_bfd);
12936   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12937
12938   rel = relocs;
12939   relend = relocs + input_section->reloc_count;
12940   for (; rel < relend; rel++)
12941     {
12942       enum elf_ppc64_reloc_type r_type;
12943       bfd_vma addend;
12944       bfd_reloc_status_type r;
12945       Elf_Internal_Sym *sym;
12946       asection *sec;
12947       struct elf_link_hash_entry *h_elf;
12948       struct ppc_link_hash_entry *h;
12949       struct ppc_link_hash_entry *fdh;
12950       const char *sym_name;
12951       unsigned long r_symndx, toc_symndx;
12952       bfd_vma toc_addend;
12953       unsigned char tls_mask, tls_gd, tls_type;
12954       unsigned char sym_type;
12955       bfd_vma relocation;
12956       bfd_boolean unresolved_reloc;
12957       bfd_boolean warned;
12958       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12959       unsigned int insn;
12960       unsigned int mask;
12961       struct ppc_stub_hash_entry *stub_entry;
12962       bfd_vma max_br_offset;
12963       bfd_vma from;
12964       const Elf_Internal_Rela orig_rel = *rel;
12965       reloc_howto_type *howto;
12966       struct reloc_howto_struct alt_howto;
12967
12968       r_type = ELF64_R_TYPE (rel->r_info);
12969       r_symndx = ELF64_R_SYM (rel->r_info);
12970
12971       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12972          symbol of the previous ADDR64 reloc.  The symbol gives us the
12973          proper TOC base to use.  */
12974       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12975           && rel != relocs
12976           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12977           && is_opd)
12978         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12979
12980       sym = NULL;
12981       sec = NULL;
12982       h_elf = NULL;
12983       sym_name = NULL;
12984       unresolved_reloc = FALSE;
12985       warned = FALSE;
12986
12987       if (r_symndx < symtab_hdr->sh_info)
12988         {
12989           /* It's a local symbol.  */
12990           struct _opd_sec_data *opd;
12991
12992           sym = local_syms + r_symndx;
12993           sec = local_sections[r_symndx];
12994           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12995           sym_type = ELF64_ST_TYPE (sym->st_info);
12996           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12997           opd = get_opd_info (sec);
12998           if (opd != NULL && opd->adjust != NULL)
12999             {
13000               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13001               if (adjust == -1)
13002                 relocation = 0;
13003               else
13004                 {
13005                   /* If this is a relocation against the opd section sym
13006                      and we have edited .opd, adjust the reloc addend so
13007                      that ld -r and ld --emit-relocs output is correct.
13008                      If it is a reloc against some other .opd symbol,
13009                      then the symbol value will be adjusted later.  */
13010                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13011                     rel->r_addend += adjust;
13012                   else
13013                     relocation += adjust;
13014                 }
13015             }
13016         }
13017       else
13018         {
13019           bfd_boolean ignored;
13020
13021           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13022                                    r_symndx, symtab_hdr, sym_hashes,
13023                                    h_elf, sec, relocation,
13024                                    unresolved_reloc, warned, ignored);
13025           sym_name = h_elf->root.root.string;
13026           sym_type = h_elf->type;
13027           if (sec != NULL
13028               && sec->owner == output_bfd
13029               && strcmp (sec->name, ".opd") == 0)
13030             {
13031               /* This is a symbol defined in a linker script.  All
13032                  such are defined in output sections, even those
13033                  defined by simple assignment from a symbol defined in
13034                  an input section.  Transfer the symbol to an
13035                  appropriate input .opd section, so that a branch to
13036                  this symbol will be mapped to the location specified
13037                  by the opd entry.  */
13038               struct bfd_link_order *lo;
13039               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13040                 if (lo->type == bfd_indirect_link_order)
13041                   {
13042                     asection *isec = lo->u.indirect.section;
13043                     if (h_elf->root.u.def.value >= isec->output_offset
13044                         && h_elf->root.u.def.value < (isec->output_offset
13045                                                       + isec->size))
13046                       {
13047                         h_elf->root.u.def.value -= isec->output_offset;
13048                         h_elf->root.u.def.section = isec;
13049                         sec = isec;
13050                         break;
13051                       }
13052                   }
13053             }
13054         }
13055       h = (struct ppc_link_hash_entry *) h_elf;
13056
13057       if (sec != NULL && discarded_section (sec))
13058         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13059                                          rel, 1, relend,
13060                                          ppc64_elf_howto_table[r_type], 0,
13061                                          contents);
13062
13063       if (info->relocatable)
13064         continue;
13065
13066       if (h != NULL && &h->elf == htab->elf.hgot)
13067         {
13068           relocation = (TOCstart
13069                         + htab->stub_group[input_section->id].toc_off);
13070           sec = bfd_abs_section_ptr;
13071           unresolved_reloc = FALSE;
13072         }
13073
13074       /* TLS optimizations.  Replace instruction sequences and relocs
13075          based on information we collected in tls_optimize.  We edit
13076          RELOCS so that --emit-relocs will output something sensible
13077          for the final instruction stream.  */
13078       tls_mask = 0;
13079       tls_gd = 0;
13080       toc_symndx = 0;
13081       if (h != NULL)
13082         tls_mask = h->tls_mask;
13083       else if (local_got_ents != NULL)
13084         {
13085           struct plt_entry **local_plt = (struct plt_entry **)
13086             (local_got_ents + symtab_hdr->sh_info);
13087           unsigned char *lgot_masks = (unsigned char *)
13088             (local_plt + symtab_hdr->sh_info);
13089           tls_mask = lgot_masks[r_symndx];
13090         }
13091       if (tls_mask == 0
13092           && (r_type == R_PPC64_TLS
13093               || r_type == R_PPC64_TLSGD
13094               || r_type == R_PPC64_TLSLD))
13095         {
13096           /* Check for toc tls entries.  */
13097           unsigned char *toc_tls;
13098
13099           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13100                              &local_syms, rel, input_bfd))
13101             return FALSE;
13102
13103           if (toc_tls)
13104             tls_mask = *toc_tls;
13105         }
13106
13107       /* Check that tls relocs are used with tls syms, and non-tls
13108          relocs are used with non-tls syms.  */
13109       if (r_symndx != STN_UNDEF
13110           && r_type != R_PPC64_NONE
13111           && (h == NULL
13112               || h->elf.root.type == bfd_link_hash_defined
13113               || h->elf.root.type == bfd_link_hash_defweak)
13114           && (IS_PPC64_TLS_RELOC (r_type)
13115               != (sym_type == STT_TLS
13116                   || (sym_type == STT_SECTION
13117                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13118         {
13119           if (tls_mask != 0
13120               && (r_type == R_PPC64_TLS
13121                   || r_type == R_PPC64_TLSGD
13122                   || r_type == R_PPC64_TLSLD))
13123             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13124             ;
13125           else
13126             info->callbacks->einfo
13127               (!IS_PPC64_TLS_RELOC (r_type)
13128                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13129                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13130                input_bfd, input_section, rel->r_offset,
13131                ppc64_elf_howto_table[r_type]->name,
13132                sym_name);
13133         }
13134
13135       /* Ensure reloc mapping code below stays sane.  */
13136       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13137           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13138           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13139           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13140           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13141           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13142           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13143           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13144           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13145           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13146         abort ();
13147
13148       switch (r_type)
13149         {
13150         default:
13151           break;
13152
13153         case R_PPC64_LO_DS_OPT:
13154           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13155           if ((insn & (0x3f << 26)) != 58u << 26)
13156             abort ();
13157           insn += (14u << 26) - (58u << 26);
13158           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13159           r_type = R_PPC64_TOC16_LO;
13160           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13161           break;
13162
13163         case R_PPC64_TOC16:
13164         case R_PPC64_TOC16_LO:
13165         case R_PPC64_TOC16_DS:
13166         case R_PPC64_TOC16_LO_DS:
13167           {
13168             /* Check for toc tls entries.  */
13169             unsigned char *toc_tls;
13170             int retval;
13171
13172             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13173                                    &local_syms, rel, input_bfd);
13174             if (retval == 0)
13175               return FALSE;
13176
13177             if (toc_tls)
13178               {
13179                 tls_mask = *toc_tls;
13180                 if (r_type == R_PPC64_TOC16_DS
13181                     || r_type == R_PPC64_TOC16_LO_DS)
13182                   {
13183                     if (tls_mask != 0
13184                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13185                       goto toctprel;
13186                   }
13187                 else
13188                   {
13189                     /* If we found a GD reloc pair, then we might be
13190                        doing a GD->IE transition.  */
13191                     if (retval == 2)
13192                       {
13193                         tls_gd = TLS_TPRELGD;
13194                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13195                           goto tls_ldgd_opt;
13196                       }
13197                     else if (retval == 3)
13198                       {
13199                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13200                           goto tls_ldgd_opt;
13201                       }
13202                   }
13203               }
13204           }
13205           break;
13206
13207         case R_PPC64_GOT_TPREL16_HI:
13208         case R_PPC64_GOT_TPREL16_HA:
13209           if (tls_mask != 0
13210               && (tls_mask & TLS_TPREL) == 0)
13211             {
13212               rel->r_offset -= d_offset;
13213               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13214               r_type = R_PPC64_NONE;
13215               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13216             }
13217           break;
13218
13219         case R_PPC64_GOT_TPREL16_DS:
13220         case R_PPC64_GOT_TPREL16_LO_DS:
13221           if (tls_mask != 0
13222               && (tls_mask & TLS_TPREL) == 0)
13223             {
13224             toctprel:
13225               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13226               insn &= 31 << 21;
13227               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13228               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13229               r_type = R_PPC64_TPREL16_HA;
13230               if (toc_symndx != 0)
13231                 {
13232                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13233                   rel->r_addend = toc_addend;
13234                   /* We changed the symbol.  Start over in order to
13235                      get h, sym, sec etc. right.  */
13236                   rel--;
13237                   continue;
13238                 }
13239               else
13240                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13241             }
13242           break;
13243
13244         case R_PPC64_TLS:
13245           if (tls_mask != 0
13246               && (tls_mask & TLS_TPREL) == 0)
13247             {
13248               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13249               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13250               if (insn == 0)
13251                 abort ();
13252               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13253               /* Was PPC64_TLS which sits on insn boundary, now
13254                  PPC64_TPREL16_LO which is at low-order half-word.  */
13255               rel->r_offset += d_offset;
13256               r_type = R_PPC64_TPREL16_LO;
13257               if (toc_symndx != 0)
13258                 {
13259                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13260                   rel->r_addend = toc_addend;
13261                   /* We changed the symbol.  Start over in order to
13262                      get h, sym, sec etc. right.  */
13263                   rel--;
13264                   continue;
13265                 }
13266               else
13267                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13268             }
13269           break;
13270
13271         case R_PPC64_GOT_TLSGD16_HI:
13272         case R_PPC64_GOT_TLSGD16_HA:
13273           tls_gd = TLS_TPRELGD;
13274           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13275             goto tls_gdld_hi;
13276           break;
13277
13278         case R_PPC64_GOT_TLSLD16_HI:
13279         case R_PPC64_GOT_TLSLD16_HA:
13280           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13281             {
13282             tls_gdld_hi:
13283               if ((tls_mask & tls_gd) != 0)
13284                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13285                           + R_PPC64_GOT_TPREL16_DS);
13286               else
13287                 {
13288                   rel->r_offset -= d_offset;
13289                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13290                   r_type = R_PPC64_NONE;
13291                 }
13292               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13293             }
13294           break;
13295
13296         case R_PPC64_GOT_TLSGD16:
13297         case R_PPC64_GOT_TLSGD16_LO:
13298           tls_gd = TLS_TPRELGD;
13299           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13300             goto tls_ldgd_opt;
13301           break;
13302
13303         case R_PPC64_GOT_TLSLD16:
13304         case R_PPC64_GOT_TLSLD16_LO:
13305           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13306             {
13307               unsigned int insn1, insn2, insn3;
13308               bfd_vma offset;
13309
13310             tls_ldgd_opt:
13311               offset = (bfd_vma) -1;
13312               /* If not using the newer R_PPC64_TLSGD/LD to mark
13313                  __tls_get_addr calls, we must trust that the call
13314                  stays with its arg setup insns, ie. that the next
13315                  reloc is the __tls_get_addr call associated with
13316                  the current reloc.  Edit both insns.  */
13317               if (input_section->has_tls_get_addr_call
13318                   && rel + 1 < relend
13319                   && branch_reloc_hash_match (input_bfd, rel + 1,
13320                                               htab->tls_get_addr,
13321                                               htab->tls_get_addr_fd))
13322                 offset = rel[1].r_offset;
13323               if ((tls_mask & tls_gd) != 0)
13324                 {
13325                   /* IE */
13326                   insn1 = bfd_get_32 (output_bfd,
13327                                       contents + rel->r_offset - d_offset);
13328                   insn1 &= (1 << 26) - (1 << 2);
13329                   insn1 |= 58 << 26;    /* ld */
13330                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13331                   if (offset != (bfd_vma) -1)
13332                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13333                   if ((tls_mask & TLS_EXPLICIT) == 0)
13334                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13335                               + R_PPC64_GOT_TPREL16_DS);
13336                   else
13337                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13338                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13339                 }
13340               else
13341                 {
13342                   /* LE */
13343                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13344                   insn2 = 0x38630000;   /* addi 3,3,0 */
13345                   if (tls_gd == 0)
13346                     {
13347                       /* Was an LD reloc.  */
13348                       if (toc_symndx)
13349                         sec = local_sections[toc_symndx];
13350                       for (r_symndx = 0;
13351                            r_symndx < symtab_hdr->sh_info;
13352                            r_symndx++)
13353                         if (local_sections[r_symndx] == sec)
13354                           break;
13355                       if (r_symndx >= symtab_hdr->sh_info)
13356                         r_symndx = STN_UNDEF;
13357                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13358                       if (r_symndx != STN_UNDEF)
13359                         rel->r_addend -= (local_syms[r_symndx].st_value
13360                                           + sec->output_offset
13361                                           + sec->output_section->vma);
13362                     }
13363                   else if (toc_symndx != 0)
13364                     {
13365                       r_symndx = toc_symndx;
13366                       rel->r_addend = toc_addend;
13367                     }
13368                   r_type = R_PPC64_TPREL16_HA;
13369                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13370                   if (offset != (bfd_vma) -1)
13371                     {
13372                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13373                                                     R_PPC64_TPREL16_LO);
13374                       rel[1].r_offset = offset + d_offset;
13375                       rel[1].r_addend = rel->r_addend;
13376                     }
13377                 }
13378               bfd_put_32 (output_bfd, insn1,
13379                           contents + rel->r_offset - d_offset);
13380               if (offset != (bfd_vma) -1)
13381                 {
13382                   insn3 = bfd_get_32 (output_bfd,
13383                                       contents + offset + 4);
13384                   if (insn3 == NOP
13385                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13386                     {
13387                       rel[1].r_offset += 4;
13388                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13389                       insn2 = NOP;
13390                     }
13391                   bfd_put_32 (output_bfd, insn2, contents + offset);
13392                 }
13393               if ((tls_mask & tls_gd) == 0
13394                   && (tls_gd == 0 || toc_symndx != 0))
13395                 {
13396                   /* We changed the symbol.  Start over in order
13397                      to get h, sym, sec etc. right.  */
13398                   rel--;
13399                   continue;
13400                 }
13401             }
13402           break;
13403
13404         case R_PPC64_TLSGD:
13405           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13406             {
13407               unsigned int insn2, insn3;
13408               bfd_vma offset = rel->r_offset;
13409
13410               if ((tls_mask & TLS_TPRELGD) != 0)
13411                 {
13412                   /* IE */
13413                   r_type = R_PPC64_NONE;
13414                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13415                 }
13416               else
13417                 {
13418                   /* LE */
13419                   if (toc_symndx != 0)
13420                     {
13421                       r_symndx = toc_symndx;
13422                       rel->r_addend = toc_addend;
13423                     }
13424                   r_type = R_PPC64_TPREL16_LO;
13425                   rel->r_offset = offset + d_offset;
13426                   insn2 = 0x38630000;   /* addi 3,3,0 */
13427                 }
13428               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13429               /* Zap the reloc on the _tls_get_addr call too.  */
13430               BFD_ASSERT (offset == rel[1].r_offset);
13431               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13432               insn3 = bfd_get_32 (output_bfd,
13433                                   contents + offset + 4);
13434               if (insn3 == NOP
13435                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13436                 {
13437                   rel->r_offset += 4;
13438                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13439                   insn2 = NOP;
13440                 }
13441               bfd_put_32 (output_bfd, insn2, contents + offset);
13442               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13443                 {
13444                   rel--;
13445                   continue;
13446                 }
13447             }
13448           break;
13449
13450         case R_PPC64_TLSLD:
13451           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13452             {
13453               unsigned int insn2, insn3;
13454               bfd_vma offset = rel->r_offset;
13455
13456               if (toc_symndx)
13457                 sec = local_sections[toc_symndx];
13458               for (r_symndx = 0;
13459                    r_symndx < symtab_hdr->sh_info;
13460                    r_symndx++)
13461                 if (local_sections[r_symndx] == sec)
13462                   break;
13463               if (r_symndx >= symtab_hdr->sh_info)
13464                 r_symndx = STN_UNDEF;
13465               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13466               if (r_symndx != STN_UNDEF)
13467                 rel->r_addend -= (local_syms[r_symndx].st_value
13468                                   + sec->output_offset
13469                                   + sec->output_section->vma);
13470
13471               r_type = R_PPC64_TPREL16_LO;
13472               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13473               rel->r_offset = offset + d_offset;
13474               /* Zap the reloc on the _tls_get_addr call too.  */
13475               BFD_ASSERT (offset == rel[1].r_offset);
13476               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13477               insn2 = 0x38630000;       /* addi 3,3,0 */
13478               insn3 = bfd_get_32 (output_bfd,
13479                                   contents + offset + 4);
13480               if (insn3 == NOP
13481                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13482                 {
13483                   rel->r_offset += 4;
13484                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13485                   insn2 = NOP;
13486                 }
13487               bfd_put_32 (output_bfd, insn2, contents + offset);
13488               rel--;
13489               continue;
13490             }
13491           break;
13492
13493         case R_PPC64_DTPMOD64:
13494           if (rel + 1 < relend
13495               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13496               && rel[1].r_offset == rel->r_offset + 8)
13497             {
13498               if ((tls_mask & TLS_GD) == 0)
13499                 {
13500                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13501                   if ((tls_mask & TLS_TPRELGD) != 0)
13502                     r_type = R_PPC64_TPREL64;
13503                   else
13504                     {
13505                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13506                       r_type = R_PPC64_NONE;
13507                     }
13508                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13509                 }
13510             }
13511           else
13512             {
13513               if ((tls_mask & TLS_LD) == 0)
13514                 {
13515                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13516                   r_type = R_PPC64_NONE;
13517                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13518                 }
13519             }
13520           break;
13521
13522         case R_PPC64_TPREL64:
13523           if ((tls_mask & TLS_TPREL) == 0)
13524             {
13525               r_type = R_PPC64_NONE;
13526               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13527             }
13528           break;
13529
13530         case R_PPC64_REL16_HA:
13531           /* If we are generating a non-PIC executable, edit
13532              .  0:      addis 2,12,.TOC.-0b@ha
13533              .          addi 2,2,.TOC.-0b@l
13534              used by ELFv2 global entry points to set up r2, to
13535              .          lis 2,.TOC.@ha
13536              .          addi 2,2,.TOC.@l
13537              if .TOC. is in range.  */
13538           if (!info->shared
13539               && h != NULL && &h->elf == htab->elf.hgot
13540               && rel + 1 < relend
13541               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13542               && rel[1].r_offset == rel->r_offset + 4
13543               && rel[1].r_addend == rel->r_addend + 4
13544               && relocation + 0x80008000 <= 0xffffffff)
13545             {
13546               unsigned int insn1, insn2;
13547               bfd_vma offset = rel->r_offset - d_offset;
13548               insn1 = bfd_get_32 (output_bfd, contents + offset);
13549               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13550               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13551                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13552                 {
13553                   r_type = R_PPC64_ADDR16_HA;
13554                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13555                   rel->r_addend -= d_offset;
13556                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13557                   rel[1].r_addend -= d_offset + 4;
13558                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13559                 }
13560             }
13561           break;
13562         }
13563
13564       /* Handle other relocations that tweak non-addend part of insn.  */
13565       insn = 0;
13566       max_br_offset = 1 << 25;
13567       addend = rel->r_addend;
13568       reloc_dest = DEST_NORMAL;
13569       switch (r_type)
13570         {
13571         default:
13572           break;
13573
13574         case R_PPC64_TOCSAVE:
13575           if (relocation + addend == (rel->r_offset
13576                                       + input_section->output_offset
13577                                       + input_section->output_section->vma)
13578               && tocsave_find (htab, NO_INSERT,
13579                                &local_syms, rel, input_bfd))
13580             {
13581               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13582               if (insn == NOP
13583                   || insn == CROR_151515 || insn == CROR_313131)
13584                 bfd_put_32 (input_bfd,
13585                             STD_R2_0R1 + STK_TOC (htab),
13586                             contents + rel->r_offset);
13587             }
13588           break;
13589
13590           /* Branch taken prediction relocations.  */
13591         case R_PPC64_ADDR14_BRTAKEN:
13592         case R_PPC64_REL14_BRTAKEN:
13593           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13594           /* Fall thru.  */
13595
13596           /* Branch not taken prediction relocations.  */
13597         case R_PPC64_ADDR14_BRNTAKEN:
13598         case R_PPC64_REL14_BRNTAKEN:
13599           insn |= bfd_get_32 (output_bfd,
13600                               contents + rel->r_offset) & ~(0x01 << 21);
13601           /* Fall thru.  */
13602
13603         case R_PPC64_REL14:
13604           max_br_offset = 1 << 15;
13605           /* Fall thru.  */
13606
13607         case R_PPC64_REL24:
13608           /* Calls to functions with a different TOC, such as calls to
13609              shared objects, need to alter the TOC pointer.  This is
13610              done using a linkage stub.  A REL24 branching to these
13611              linkage stubs needs to be followed by a nop, as the nop
13612              will be replaced with an instruction to restore the TOC
13613              base pointer.  */
13614           fdh = h;
13615           if (h != NULL
13616               && h->oh != NULL
13617               && h->oh->is_func_descriptor)
13618             fdh = ppc_follow_link (h->oh);
13619           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13620                                            htab);
13621           if (stub_entry != NULL
13622               && (stub_entry->stub_type == ppc_stub_plt_call
13623                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13624                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13625                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13626             {
13627               bfd_boolean can_plt_call = FALSE;
13628
13629               /* All of these stubs will modify r2, so there must be a
13630                  branch and link followed by a nop.  The nop is
13631                  replaced by an insn to restore r2.  */
13632               if (rel->r_offset + 8 <= input_section->size)
13633                 {
13634                   unsigned long br;
13635
13636                   br = bfd_get_32 (input_bfd,
13637                                    contents + rel->r_offset);
13638                   if ((br & 1) != 0)
13639                     {
13640                       unsigned long nop;
13641
13642                       nop = bfd_get_32 (input_bfd,
13643                                         contents + rel->r_offset + 4);
13644                       if (nop == NOP
13645                           || nop == CROR_151515 || nop == CROR_313131)
13646                         {
13647                           if (h != NULL
13648                               && (h == htab->tls_get_addr_fd
13649                                   || h == htab->tls_get_addr)
13650                               && !htab->params->no_tls_get_addr_opt)
13651                             {
13652                               /* Special stub used, leave nop alone.  */
13653                             }
13654                           else
13655                             bfd_put_32 (input_bfd,
13656                                         LD_R2_0R1 + STK_TOC (htab),
13657                                         contents + rel->r_offset + 4);
13658                           can_plt_call = TRUE;
13659                         }
13660                     }
13661                 }
13662
13663               if (!can_plt_call && h != NULL)
13664                 {
13665                   const char *name = h->elf.root.root.string;
13666
13667                   if (*name == '.')
13668                     ++name;
13669
13670                   if (strncmp (name, "__libc_start_main", 17) == 0
13671                       && (name[17] == 0 || name[17] == '@'))
13672                     {
13673                       /* Allow crt1 branch to go via a toc adjusting
13674                          stub.  Other calls that never return could do
13675                          the same, if we could detect such.  */
13676                       can_plt_call = TRUE;
13677                     }
13678                 }
13679
13680               if (!can_plt_call)
13681                 {
13682                   /* g++ as of 20130507 emits self-calls without a
13683                      following nop.  This is arguably wrong since we
13684                      have conflicting information.  On the one hand a
13685                      global symbol and on the other a local call
13686                      sequence, but don't error for this special case.
13687                      It isn't possible to cheaply verify we have
13688                      exactly such a call.  Allow all calls to the same
13689                      section.  */
13690                   asection *code_sec = sec;
13691
13692                   if (get_opd_info (sec) != NULL)
13693                     {
13694                       bfd_vma off = (relocation + addend
13695                                      - sec->output_section->vma
13696                                      - sec->output_offset);
13697
13698                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13699                     }
13700                   if (code_sec == input_section)
13701                     can_plt_call = TRUE;
13702                 }
13703
13704               if (!can_plt_call)
13705                 {
13706                   info->callbacks->einfo
13707                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13708                        "recompile with -fPIC\n"),
13709                      input_bfd, input_section, rel->r_offset, sym_name);
13710
13711                   bfd_set_error (bfd_error_bad_value);
13712                   ret = FALSE;
13713                 }
13714
13715               if (can_plt_call
13716                   && (stub_entry->stub_type == ppc_stub_plt_call
13717                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13718                 unresolved_reloc = FALSE;
13719             }
13720
13721           if ((stub_entry == NULL
13722                || stub_entry->stub_type == ppc_stub_long_branch
13723                || stub_entry->stub_type == ppc_stub_plt_branch)
13724               && get_opd_info (sec) != NULL)
13725             {
13726               /* The branch destination is the value of the opd entry. */
13727               bfd_vma off = (relocation + addend
13728                              - sec->output_section->vma
13729                              - sec->output_offset);
13730               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13731               if (dest != (bfd_vma) -1)
13732                 {
13733                   relocation = dest;
13734                   addend = 0;
13735                   reloc_dest = DEST_OPD;
13736                 }
13737             }
13738
13739           /* If the branch is out of reach we ought to have a long
13740              branch stub.  */
13741           from = (rel->r_offset
13742                   + input_section->output_offset
13743                   + input_section->output_section->vma);
13744
13745           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13746                                                   ? fdh->elf.other
13747                                                   : sym->st_other);
13748
13749           if (stub_entry != NULL
13750               && (stub_entry->stub_type == ppc_stub_long_branch
13751                   || stub_entry->stub_type == ppc_stub_plt_branch)
13752               && (r_type == R_PPC64_ADDR14_BRTAKEN
13753                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13754                   || (relocation + addend - from + max_br_offset
13755                       < 2 * max_br_offset)))
13756             /* Don't use the stub if this branch is in range.  */
13757             stub_entry = NULL;
13758
13759           if (stub_entry != NULL)
13760             {
13761               /* Munge up the value and addend so that we call the stub
13762                  rather than the procedure directly.  */
13763               relocation = (stub_entry->stub_offset
13764                             + stub_entry->stub_sec->output_offset
13765                             + stub_entry->stub_sec->output_section->vma);
13766               addend = 0;
13767               reloc_dest = DEST_STUB;
13768
13769               if ((stub_entry->stub_type == ppc_stub_plt_call
13770                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13771                   && (ALWAYS_EMIT_R2SAVE
13772                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13773                   && rel + 1 < relend
13774                   && rel[1].r_offset == rel->r_offset + 4
13775                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13776                 relocation += 4;
13777             }
13778
13779           if (insn != 0)
13780             {
13781               if (is_isa_v2)
13782                 {
13783                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13784                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13785                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13786                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13787                     insn |= 0x02 << 21;
13788                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13789                     insn |= 0x08 << 21;
13790                   else
13791                     break;
13792                 }
13793               else
13794                 {
13795                   /* Invert 'y' bit if not the default.  */
13796                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13797                     insn ^= 0x01 << 21;
13798                 }
13799
13800               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13801             }
13802
13803           /* NOP out calls to undefined weak functions.
13804              We can thus call a weak function without first
13805              checking whether the function is defined.  */
13806           else if (h != NULL
13807                    && h->elf.root.type == bfd_link_hash_undefweak
13808                    && h->elf.dynindx == -1
13809                    && r_type == R_PPC64_REL24
13810                    && relocation == 0
13811                    && addend == 0)
13812             {
13813               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13814               continue;
13815             }
13816           break;
13817         }
13818
13819       /* Set `addend'.  */
13820       tls_type = 0;
13821       switch (r_type)
13822         {
13823         default:
13824           info->callbacks->einfo
13825             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13826              input_bfd, (int) r_type, sym_name);
13827
13828           bfd_set_error (bfd_error_bad_value);
13829           ret = FALSE;
13830           continue;
13831
13832         case R_PPC64_NONE:
13833         case R_PPC64_TLS:
13834         case R_PPC64_TLSGD:
13835         case R_PPC64_TLSLD:
13836         case R_PPC64_TOCSAVE:
13837         case R_PPC64_GNU_VTINHERIT:
13838         case R_PPC64_GNU_VTENTRY:
13839           continue;
13840
13841           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13842              address in the GOT as relocation value instead of the
13843              symbol's value itself.  Also, create a GOT entry for the
13844              symbol and put the symbol value there.  */
13845         case R_PPC64_GOT_TLSGD16:
13846         case R_PPC64_GOT_TLSGD16_LO:
13847         case R_PPC64_GOT_TLSGD16_HI:
13848         case R_PPC64_GOT_TLSGD16_HA:
13849           tls_type = TLS_TLS | TLS_GD;
13850           goto dogot;
13851
13852         case R_PPC64_GOT_TLSLD16:
13853         case R_PPC64_GOT_TLSLD16_LO:
13854         case R_PPC64_GOT_TLSLD16_HI:
13855         case R_PPC64_GOT_TLSLD16_HA:
13856           tls_type = TLS_TLS | TLS_LD;
13857           goto dogot;
13858
13859         case R_PPC64_GOT_TPREL16_DS:
13860         case R_PPC64_GOT_TPREL16_LO_DS:
13861         case R_PPC64_GOT_TPREL16_HI:
13862         case R_PPC64_GOT_TPREL16_HA:
13863           tls_type = TLS_TLS | TLS_TPREL;
13864           goto dogot;
13865
13866         case R_PPC64_GOT_DTPREL16_DS:
13867         case R_PPC64_GOT_DTPREL16_LO_DS:
13868         case R_PPC64_GOT_DTPREL16_HI:
13869         case R_PPC64_GOT_DTPREL16_HA:
13870           tls_type = TLS_TLS | TLS_DTPREL;
13871           goto dogot;
13872
13873         case R_PPC64_GOT16:
13874         case R_PPC64_GOT16_LO:
13875         case R_PPC64_GOT16_HI:
13876         case R_PPC64_GOT16_HA:
13877         case R_PPC64_GOT16_DS:
13878         case R_PPC64_GOT16_LO_DS:
13879         dogot:
13880           {
13881             /* Relocation is to the entry for this symbol in the global
13882                offset table.  */
13883             asection *got;
13884             bfd_vma *offp;
13885             bfd_vma off;
13886             unsigned long indx = 0;
13887             struct got_entry *ent;
13888
13889             if (tls_type == (TLS_TLS | TLS_LD)
13890                 && (h == NULL
13891                     || !h->elf.def_dynamic))
13892               ent = ppc64_tlsld_got (input_bfd);
13893             else
13894               {
13895
13896                 if (h != NULL)
13897                   {
13898                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13899                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13900                                                           &h->elf)
13901                         || (info->shared
13902                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13903                       /* This is actually a static link, or it is a
13904                          -Bsymbolic link and the symbol is defined
13905                          locally, or the symbol was forced to be local
13906                          because of a version file.  */
13907                       ;
13908                     else
13909                       {
13910                         BFD_ASSERT (h->elf.dynindx != -1);
13911                         indx = h->elf.dynindx;
13912                         unresolved_reloc = FALSE;
13913                       }
13914                     ent = h->elf.got.glist;
13915                   }
13916                 else
13917                   {
13918                     if (local_got_ents == NULL)
13919                       abort ();
13920                     ent = local_got_ents[r_symndx];
13921                   }
13922
13923                 for (; ent != NULL; ent = ent->next)
13924                   if (ent->addend == orig_rel.r_addend
13925                       && ent->owner == input_bfd
13926                       && ent->tls_type == tls_type)
13927                     break;
13928               }
13929
13930             if (ent == NULL)
13931               abort ();
13932             if (ent->is_indirect)
13933               ent = ent->got.ent;
13934             offp = &ent->got.offset;
13935             got = ppc64_elf_tdata (ent->owner)->got;
13936             if (got == NULL)
13937               abort ();
13938
13939             /* The offset must always be a multiple of 8.  We use the
13940                least significant bit to record whether we have already
13941                processed this entry.  */
13942             off = *offp;
13943             if ((off & 1) != 0)
13944               off &= ~1;
13945             else
13946               {
13947                 /* Generate relocs for the dynamic linker, except in
13948                    the case of TLSLD where we'll use one entry per
13949                    module.  */
13950                 asection *relgot;
13951                 bfd_boolean ifunc;
13952
13953                 *offp = off | 1;
13954                 relgot = NULL;
13955                 ifunc = (h != NULL
13956                          ? h->elf.type == STT_GNU_IFUNC
13957                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13958                 if (ifunc)
13959                   relgot = htab->elf.irelplt;
13960                 else if ((info->shared || indx != 0)
13961                          && (h == NULL
13962                              || (tls_type == (TLS_TLS | TLS_LD)
13963                                  && !h->elf.def_dynamic)
13964                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13965                              || h->elf.root.type != bfd_link_hash_undefweak))
13966                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13967                 if (relgot != NULL)
13968                   {
13969                     outrel.r_offset = (got->output_section->vma
13970                                        + got->output_offset
13971                                        + off);
13972                     outrel.r_addend = addend;
13973                     if (tls_type & (TLS_LD | TLS_GD))
13974                       {
13975                         outrel.r_addend = 0;
13976                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13977                         if (tls_type == (TLS_TLS | TLS_GD))
13978                           {
13979                             loc = relgot->contents;
13980                             loc += (relgot->reloc_count++
13981                                     * sizeof (Elf64_External_Rela));
13982                             bfd_elf64_swap_reloca_out (output_bfd,
13983                                                        &outrel, loc);
13984                             outrel.r_offset += 8;
13985                             outrel.r_addend = addend;
13986                             outrel.r_info
13987                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13988                           }
13989                       }
13990                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13991                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13992                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13993                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13994                     else if (indx != 0)
13995                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13996                     else
13997                       {
13998                         if (ifunc)
13999                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14000                         else
14001                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14002
14003                         /* Write the .got section contents for the sake
14004                            of prelink.  */
14005                         loc = got->contents + off;
14006                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14007                                     loc);
14008                       }
14009
14010                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14011                       {
14012                         outrel.r_addend += relocation;
14013                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14014                           outrel.r_addend -= htab->elf.tls_sec->vma;
14015                       }
14016                     loc = relgot->contents;
14017                     loc += (relgot->reloc_count++
14018                             * sizeof (Elf64_External_Rela));
14019                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14020                   }
14021
14022                 /* Init the .got section contents here if we're not
14023                    emitting a reloc.  */
14024                 else
14025                   {
14026                     relocation += addend;
14027                     if (tls_type == (TLS_TLS | TLS_LD))
14028                       relocation = 1;
14029                     else if (tls_type != 0)
14030                       {
14031                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14032                         if (tls_type == (TLS_TLS | TLS_TPREL))
14033                           relocation += DTP_OFFSET - TP_OFFSET;
14034
14035                         if (tls_type == (TLS_TLS | TLS_GD))
14036                           {
14037                             bfd_put_64 (output_bfd, relocation,
14038                                         got->contents + off + 8);
14039                             relocation = 1;
14040                           }
14041                       }
14042
14043                     bfd_put_64 (output_bfd, relocation,
14044                                 got->contents + off);
14045                   }
14046               }
14047
14048             if (off >= (bfd_vma) -2)
14049               abort ();
14050
14051             relocation = got->output_section->vma + got->output_offset + off;
14052             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14053           }
14054           break;
14055
14056         case R_PPC64_PLT16_HA:
14057         case R_PPC64_PLT16_HI:
14058         case R_PPC64_PLT16_LO:
14059         case R_PPC64_PLT32:
14060         case R_PPC64_PLT64:
14061           /* Relocation is to the entry for this symbol in the
14062              procedure linkage table.  */
14063
14064           /* Resolve a PLT reloc against a local symbol directly,
14065              without using the procedure linkage table.  */
14066           if (h == NULL)
14067             break;
14068
14069           /* It's possible that we didn't make a PLT entry for this
14070              symbol.  This happens when statically linking PIC code,
14071              or when using -Bsymbolic.  Go find a match if there is a
14072              PLT entry.  */
14073           if (htab->elf.splt != NULL)
14074             {
14075               struct plt_entry *ent;
14076               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14077                 if (ent->plt.offset != (bfd_vma) -1
14078                     && ent->addend == orig_rel.r_addend)
14079                   {
14080                     relocation = (htab->elf.splt->output_section->vma
14081                                   + htab->elf.splt->output_offset
14082                                   + ent->plt.offset);
14083                     unresolved_reloc = FALSE;
14084                     break;
14085                   }
14086             }
14087           break;
14088
14089         case R_PPC64_TOC:
14090           /* Relocation value is TOC base.  */
14091           relocation = TOCstart;
14092           if (r_symndx == STN_UNDEF)
14093             relocation += htab->stub_group[input_section->id].toc_off;
14094           else if (unresolved_reloc)
14095             ;
14096           else if (sec != NULL && sec->id <= htab->top_id)
14097             relocation += htab->stub_group[sec->id].toc_off;
14098           else
14099             unresolved_reloc = TRUE;
14100           goto dodyn;
14101
14102           /* TOC16 relocs.  We want the offset relative to the TOC base,
14103              which is the address of the start of the TOC plus 0x8000.
14104              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14105              in this order.  */
14106         case R_PPC64_TOC16:
14107         case R_PPC64_TOC16_LO:
14108         case R_PPC64_TOC16_HI:
14109         case R_PPC64_TOC16_DS:
14110         case R_PPC64_TOC16_LO_DS:
14111         case R_PPC64_TOC16_HA:
14112           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14113           break;
14114
14115           /* Relocate against the beginning of the section.  */
14116         case R_PPC64_SECTOFF:
14117         case R_PPC64_SECTOFF_LO:
14118         case R_PPC64_SECTOFF_HI:
14119         case R_PPC64_SECTOFF_DS:
14120         case R_PPC64_SECTOFF_LO_DS:
14121         case R_PPC64_SECTOFF_HA:
14122           if (sec != NULL)
14123             addend -= sec->output_section->vma;
14124           break;
14125
14126         case R_PPC64_REL16:
14127         case R_PPC64_REL16_LO:
14128         case R_PPC64_REL16_HI:
14129         case R_PPC64_REL16_HA:
14130           break;
14131
14132         case R_PPC64_REL14:
14133         case R_PPC64_REL14_BRNTAKEN:
14134         case R_PPC64_REL14_BRTAKEN:
14135         case R_PPC64_REL24:
14136           break;
14137
14138         case R_PPC64_TPREL16:
14139         case R_PPC64_TPREL16_LO:
14140         case R_PPC64_TPREL16_HI:
14141         case R_PPC64_TPREL16_HA:
14142         case R_PPC64_TPREL16_DS:
14143         case R_PPC64_TPREL16_LO_DS:
14144         case R_PPC64_TPREL16_HIGH:
14145         case R_PPC64_TPREL16_HIGHA:
14146         case R_PPC64_TPREL16_HIGHER:
14147         case R_PPC64_TPREL16_HIGHERA:
14148         case R_PPC64_TPREL16_HIGHEST:
14149         case R_PPC64_TPREL16_HIGHESTA:
14150           if (h != NULL
14151               && h->elf.root.type == bfd_link_hash_undefweak
14152               && h->elf.dynindx == -1)
14153             {
14154               /* Make this relocation against an undefined weak symbol
14155                  resolve to zero.  This is really just a tweak, since
14156                  code using weak externs ought to check that they are
14157                  defined before using them.  */
14158               bfd_byte *p = contents + rel->r_offset - d_offset;
14159
14160               insn = bfd_get_32 (output_bfd, p);
14161               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14162               if (insn != 0)
14163                 bfd_put_32 (output_bfd, insn, p);
14164               break;
14165             }
14166           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14167           if (info->shared)
14168             /* The TPREL16 relocs shouldn't really be used in shared
14169                libs as they will result in DT_TEXTREL being set, but
14170                support them anyway.  */
14171             goto dodyn;
14172           break;
14173
14174         case R_PPC64_DTPREL16:
14175         case R_PPC64_DTPREL16_LO:
14176         case R_PPC64_DTPREL16_HI:
14177         case R_PPC64_DTPREL16_HA:
14178         case R_PPC64_DTPREL16_DS:
14179         case R_PPC64_DTPREL16_LO_DS:
14180         case R_PPC64_DTPREL16_HIGH:
14181         case R_PPC64_DTPREL16_HIGHA:
14182         case R_PPC64_DTPREL16_HIGHER:
14183         case R_PPC64_DTPREL16_HIGHERA:
14184         case R_PPC64_DTPREL16_HIGHEST:
14185         case R_PPC64_DTPREL16_HIGHESTA:
14186           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14187           break;
14188
14189         case R_PPC64_ADDR64_LOCAL:
14190           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14191                                               ? h->elf.other
14192                                               : sym->st_other);
14193           break;
14194
14195         case R_PPC64_DTPMOD64:
14196           relocation = 1;
14197           addend = 0;
14198           goto dodyn;
14199
14200         case R_PPC64_TPREL64:
14201           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14202           goto dodyn;
14203
14204         case R_PPC64_DTPREL64:
14205           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14206           /* Fall thru */
14207
14208           /* Relocations that may need to be propagated if this is a
14209              dynamic object.  */
14210         case R_PPC64_REL30:
14211         case R_PPC64_REL32:
14212         case R_PPC64_REL64:
14213         case R_PPC64_ADDR14:
14214         case R_PPC64_ADDR14_BRNTAKEN:
14215         case R_PPC64_ADDR14_BRTAKEN:
14216         case R_PPC64_ADDR16:
14217         case R_PPC64_ADDR16_DS:
14218         case R_PPC64_ADDR16_HA:
14219         case R_PPC64_ADDR16_HI:
14220         case R_PPC64_ADDR16_HIGH:
14221         case R_PPC64_ADDR16_HIGHA:
14222         case R_PPC64_ADDR16_HIGHER:
14223         case R_PPC64_ADDR16_HIGHERA:
14224         case R_PPC64_ADDR16_HIGHEST:
14225         case R_PPC64_ADDR16_HIGHESTA:
14226         case R_PPC64_ADDR16_LO:
14227         case R_PPC64_ADDR16_LO_DS:
14228         case R_PPC64_ADDR24:
14229         case R_PPC64_ADDR32:
14230         case R_PPC64_ADDR64:
14231         case R_PPC64_UADDR16:
14232         case R_PPC64_UADDR32:
14233         case R_PPC64_UADDR64:
14234         dodyn:
14235           if ((input_section->flags & SEC_ALLOC) == 0)
14236             break;
14237
14238           if (NO_OPD_RELOCS && is_opd)
14239             break;
14240
14241           if ((info->shared
14242                && (h == NULL
14243                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14244                    || h->elf.root.type != bfd_link_hash_undefweak)
14245                && (must_be_dyn_reloc (info, r_type)
14246                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14247               || (ELIMINATE_COPY_RELOCS
14248                   && !info->shared
14249                   && h != NULL
14250                   && h->elf.dynindx != -1
14251                   && !h->elf.non_got_ref
14252                   && !h->elf.def_regular)
14253               || (!info->shared
14254                   && (h != NULL
14255                       ? h->elf.type == STT_GNU_IFUNC
14256                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14257             {
14258               bfd_boolean skip, relocate;
14259               asection *sreloc;
14260               bfd_vma out_off;
14261
14262               /* When generating a dynamic object, these relocations
14263                  are copied into the output file to be resolved at run
14264                  time.  */
14265
14266               skip = FALSE;
14267               relocate = FALSE;
14268
14269               out_off = _bfd_elf_section_offset (output_bfd, info,
14270                                                  input_section, rel->r_offset);
14271               if (out_off == (bfd_vma) -1)
14272                 skip = TRUE;
14273               else if (out_off == (bfd_vma) -2)
14274                 skip = TRUE, relocate = TRUE;
14275               out_off += (input_section->output_section->vma
14276                           + input_section->output_offset);
14277               outrel.r_offset = out_off;
14278               outrel.r_addend = rel->r_addend;
14279
14280               /* Optimize unaligned reloc use.  */
14281               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14282                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14283                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14284               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14285                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14286                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14287               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14288                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14289                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14290
14291               if (skip)
14292                 memset (&outrel, 0, sizeof outrel);
14293               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14294                        && !is_opd
14295                        && r_type != R_PPC64_TOC)
14296                 {
14297                   BFD_ASSERT (h->elf.dynindx != -1);
14298                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14299                 }
14300               else
14301                 {
14302                   /* This symbol is local, or marked to become local,
14303                      or this is an opd section reloc which must point
14304                      at a local function.  */
14305                   outrel.r_addend += relocation;
14306                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14307                     {
14308                       if (is_opd && h != NULL)
14309                         {
14310                           /* Lie about opd entries.  This case occurs
14311                              when building shared libraries and we
14312                              reference a function in another shared
14313                              lib.  The same thing happens for a weak
14314                              definition in an application that's
14315                              overridden by a strong definition in a
14316                              shared lib.  (I believe this is a generic
14317                              bug in binutils handling of weak syms.)
14318                              In these cases we won't use the opd
14319                              entry in this lib.  */
14320                           unresolved_reloc = FALSE;
14321                         }
14322                       if (!is_opd
14323                           && r_type == R_PPC64_ADDR64
14324                           && (h != NULL
14325                               ? h->elf.type == STT_GNU_IFUNC
14326                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14327                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14328                       else
14329                         {
14330                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14331
14332                           /* We need to relocate .opd contents for ld.so.
14333                              Prelink also wants simple and consistent rules
14334                              for relocs.  This make all RELATIVE relocs have
14335                              *r_offset equal to r_addend.  */
14336                           relocate = TRUE;
14337                         }
14338                     }
14339                   else
14340                     {
14341                       long indx = 0;
14342
14343                       if (h != NULL
14344                           ? h->elf.type == STT_GNU_IFUNC
14345                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14346                         {
14347                           info->callbacks->einfo
14348                             (_("%P: %H: %s for indirect "
14349                                "function `%T' unsupported\n"),
14350                              input_bfd, input_section, rel->r_offset,
14351                              ppc64_elf_howto_table[r_type]->name,
14352                              sym_name);
14353                           ret = FALSE;
14354                         }
14355                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14356                         ;
14357                       else if (sec == NULL || sec->owner == NULL)
14358                         {
14359                           bfd_set_error (bfd_error_bad_value);
14360                           return FALSE;
14361                         }
14362                       else
14363                         {
14364                           asection *osec;
14365
14366                           osec = sec->output_section;
14367                           indx = elf_section_data (osec)->dynindx;
14368
14369                           if (indx == 0)
14370                             {
14371                               if ((osec->flags & SEC_READONLY) == 0
14372                                   && htab->elf.data_index_section != NULL)
14373                                 osec = htab->elf.data_index_section;
14374                               else
14375                                 osec = htab->elf.text_index_section;
14376                               indx = elf_section_data (osec)->dynindx;
14377                             }
14378                           BFD_ASSERT (indx != 0);
14379
14380                           /* We are turning this relocation into one
14381                              against a section symbol, so subtract out
14382                              the output section's address but not the
14383                              offset of the input section in the output
14384                              section.  */
14385                           outrel.r_addend -= osec->vma;
14386                         }
14387
14388                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14389                     }
14390                 }
14391
14392               sreloc = elf_section_data (input_section)->sreloc;
14393               if (h != NULL
14394                   ? h->elf.type == STT_GNU_IFUNC
14395                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14396                 sreloc = htab->elf.irelplt;
14397               if (sreloc == NULL)
14398                 abort ();
14399
14400               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14401                   >= sreloc->size)
14402                 abort ();
14403               loc = sreloc->contents;
14404               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14405               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14406
14407               /* If this reloc is against an external symbol, it will
14408                  be computed at runtime, so there's no need to do
14409                  anything now.  However, for the sake of prelink ensure
14410                  that the section contents are a known value.  */
14411               if (! relocate)
14412                 {
14413                   unresolved_reloc = FALSE;
14414                   /* The value chosen here is quite arbitrary as ld.so
14415                      ignores section contents except for the special
14416                      case of .opd where the contents might be accessed
14417                      before relocation.  Choose zero, as that won't
14418                      cause reloc overflow.  */
14419                   relocation = 0;
14420                   addend = 0;
14421                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14422                      to improve backward compatibility with older
14423                      versions of ld.  */
14424                   if (r_type == R_PPC64_ADDR64)
14425                     addend = outrel.r_addend;
14426                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14427                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14428                     addend = (input_section->output_section->vma
14429                               + input_section->output_offset
14430                               + rel->r_offset);
14431                 }
14432             }
14433           break;
14434
14435         case R_PPC64_COPY:
14436         case R_PPC64_GLOB_DAT:
14437         case R_PPC64_JMP_SLOT:
14438         case R_PPC64_JMP_IREL:
14439         case R_PPC64_RELATIVE:
14440           /* We shouldn't ever see these dynamic relocs in relocatable
14441              files.  */
14442           /* Fall through.  */
14443
14444         case R_PPC64_PLTGOT16:
14445         case R_PPC64_PLTGOT16_DS:
14446         case R_PPC64_PLTGOT16_HA:
14447         case R_PPC64_PLTGOT16_HI:
14448         case R_PPC64_PLTGOT16_LO:
14449         case R_PPC64_PLTGOT16_LO_DS:
14450         case R_PPC64_PLTREL32:
14451         case R_PPC64_PLTREL64:
14452           /* These ones haven't been implemented yet.  */
14453
14454           info->callbacks->einfo
14455             (_("%P: %B: %s is not supported for `%T'\n"),
14456              input_bfd,
14457              ppc64_elf_howto_table[r_type]->name, sym_name);
14458
14459           bfd_set_error (bfd_error_invalid_operation);
14460           ret = FALSE;
14461           continue;
14462         }
14463
14464       /* Multi-instruction sequences that access the TOC can be
14465          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14466          to             nop;           addi rb,r2,x;  */
14467       switch (r_type)
14468         {
14469         default:
14470           break;
14471
14472         case R_PPC64_GOT_TLSLD16_HI:
14473         case R_PPC64_GOT_TLSGD16_HI:
14474         case R_PPC64_GOT_TPREL16_HI:
14475         case R_PPC64_GOT_DTPREL16_HI:
14476         case R_PPC64_GOT16_HI:
14477         case R_PPC64_TOC16_HI:
14478           /* These relocs would only be useful if building up an
14479              offset to later add to r2, perhaps in an indexed
14480              addressing mode instruction.  Don't try to optimize.
14481              Unfortunately, the possibility of someone building up an
14482              offset like this or even with the HA relocs, means that
14483              we need to check the high insn when optimizing the low
14484              insn.  */
14485           break;
14486
14487         case R_PPC64_GOT_TLSLD16_HA:
14488         case R_PPC64_GOT_TLSGD16_HA:
14489         case R_PPC64_GOT_TPREL16_HA:
14490         case R_PPC64_GOT_DTPREL16_HA:
14491         case R_PPC64_GOT16_HA:
14492         case R_PPC64_TOC16_HA:
14493           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14494               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14495             {
14496               bfd_byte *p = contents + (rel->r_offset & ~3);
14497               bfd_put_32 (input_bfd, NOP, p);
14498             }
14499           break;
14500
14501         case R_PPC64_GOT_TLSLD16_LO:
14502         case R_PPC64_GOT_TLSGD16_LO:
14503         case R_PPC64_GOT_TPREL16_LO_DS:
14504         case R_PPC64_GOT_DTPREL16_LO_DS:
14505         case R_PPC64_GOT16_LO:
14506         case R_PPC64_GOT16_LO_DS:
14507         case R_PPC64_TOC16_LO:
14508         case R_PPC64_TOC16_LO_DS:
14509           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14510               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14511             {
14512               bfd_byte *p = contents + (rel->r_offset & ~3);
14513               insn = bfd_get_32 (input_bfd, p);
14514               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14515                 {
14516                   /* Transform addic to addi when we change reg.  */
14517                   insn &= ~((0x3f << 26) | (0x1f << 16));
14518                   insn |= (14u << 26) | (2 << 16);
14519                 }
14520               else
14521                 {
14522                   insn &= ~(0x1f << 16);
14523                   insn |= 2 << 16;
14524                 }
14525               bfd_put_32 (input_bfd, insn, p);
14526             }
14527           break;
14528         }
14529
14530       /* Do any further special processing.  */
14531       howto = ppc64_elf_howto_table[(int) r_type];
14532       switch (r_type)
14533         {
14534         default:
14535           break;
14536
14537         case R_PPC64_REL16_HA:
14538         case R_PPC64_ADDR16_HA:
14539         case R_PPC64_ADDR16_HIGHA:
14540         case R_PPC64_ADDR16_HIGHERA:
14541         case R_PPC64_ADDR16_HIGHESTA:
14542         case R_PPC64_TOC16_HA:
14543         case R_PPC64_SECTOFF_HA:
14544         case R_PPC64_TPREL16_HA:
14545         case R_PPC64_TPREL16_HIGHA:
14546         case R_PPC64_TPREL16_HIGHERA:
14547         case R_PPC64_TPREL16_HIGHESTA:
14548         case R_PPC64_DTPREL16_HA:
14549         case R_PPC64_DTPREL16_HIGHA:
14550         case R_PPC64_DTPREL16_HIGHERA:
14551         case R_PPC64_DTPREL16_HIGHESTA:
14552           /* It's just possible that this symbol is a weak symbol
14553              that's not actually defined anywhere. In that case,
14554              'sec' would be NULL, and we should leave the symbol
14555              alone (it will be set to zero elsewhere in the link).  */
14556           if (sec == NULL)
14557             break;
14558           /* Fall thru */
14559
14560         case R_PPC64_GOT16_HA:
14561         case R_PPC64_PLTGOT16_HA:
14562         case R_PPC64_PLT16_HA:
14563         case R_PPC64_GOT_TLSGD16_HA:
14564         case R_PPC64_GOT_TLSLD16_HA:
14565         case R_PPC64_GOT_TPREL16_HA:
14566         case R_PPC64_GOT_DTPREL16_HA:
14567           /* Add 0x10000 if sign bit in 0:15 is set.
14568              Bits 0:15 are not used.  */
14569           addend += 0x8000;
14570           break;
14571
14572         case R_PPC64_ADDR16_DS:
14573         case R_PPC64_ADDR16_LO_DS:
14574         case R_PPC64_GOT16_DS:
14575         case R_PPC64_GOT16_LO_DS:
14576         case R_PPC64_PLT16_LO_DS:
14577         case R_PPC64_SECTOFF_DS:
14578         case R_PPC64_SECTOFF_LO_DS:
14579         case R_PPC64_TOC16_DS:
14580         case R_PPC64_TOC16_LO_DS:
14581         case R_PPC64_PLTGOT16_DS:
14582         case R_PPC64_PLTGOT16_LO_DS:
14583         case R_PPC64_GOT_TPREL16_DS:
14584         case R_PPC64_GOT_TPREL16_LO_DS:
14585         case R_PPC64_GOT_DTPREL16_DS:
14586         case R_PPC64_GOT_DTPREL16_LO_DS:
14587         case R_PPC64_TPREL16_DS:
14588         case R_PPC64_TPREL16_LO_DS:
14589         case R_PPC64_DTPREL16_DS:
14590         case R_PPC64_DTPREL16_LO_DS:
14591           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14592           mask = 3;
14593           /* If this reloc is against an lq insn, then the value must be
14594              a multiple of 16.  This is somewhat of a hack, but the
14595              "correct" way to do this by defining _DQ forms of all the
14596              _DS relocs bloats all reloc switches in this file.  It
14597              doesn't seem to make much sense to use any of these relocs
14598              in data, so testing the insn should be safe.  */
14599           if ((insn & (0x3f << 26)) == (56u << 26))
14600             mask = 15;
14601           if (((relocation + addend) & mask) != 0)
14602             {
14603               info->callbacks->einfo
14604                 (_("%P: %H: error: %s not a multiple of %u\n"),
14605                  input_bfd, input_section, rel->r_offset,
14606                  howto->name,
14607                  mask + 1);
14608               bfd_set_error (bfd_error_bad_value);
14609               ret = FALSE;
14610               continue;
14611             }
14612           break;
14613         }
14614
14615       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14616          because such sections are not SEC_ALLOC and thus ld.so will
14617          not process them.  */
14618       if (unresolved_reloc
14619           && !((input_section->flags & SEC_DEBUGGING) != 0
14620                && h->elf.def_dynamic)
14621           && _bfd_elf_section_offset (output_bfd, info, input_section,
14622                                       rel->r_offset) != (bfd_vma) -1)
14623         {
14624           info->callbacks->einfo
14625             (_("%P: %H: unresolvable %s against `%T'\n"),
14626              input_bfd, input_section, rel->r_offset,
14627              howto->name,
14628              h->elf.root.root.string);
14629           ret = FALSE;
14630         }
14631
14632       /* 16-bit fields in insns mostly have signed values, but a
14633          few insns have 16-bit unsigned values.  Really, we should
14634          have different reloc types.  */
14635       if (howto->complain_on_overflow != complain_overflow_dont
14636           && howto->dst_mask == 0xffff
14637           && (input_section->flags & SEC_CODE) != 0)
14638         {
14639           enum complain_overflow complain = complain_overflow_signed;
14640
14641           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14642           if (howto->rightshift == 0
14643               ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14644                  || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14645                  || (insn & (0x3f << 26)) == 26u << 26 /* xori */
14646                  || (insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14647               : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14648                  || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14649                  || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14650             complain = complain_overflow_unsigned;
14651           if (howto->complain_on_overflow != complain)
14652             {
14653               alt_howto = *howto;
14654               alt_howto.complain_on_overflow = complain;
14655               howto = &alt_howto;
14656             }
14657         }
14658
14659       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14660                                     rel->r_offset, relocation, addend);
14661
14662       if (r != bfd_reloc_ok)
14663         {
14664           char *more_info = NULL;
14665           const char *reloc_name = howto->name;
14666
14667           if (reloc_dest != DEST_NORMAL)
14668             {
14669               more_info = bfd_malloc (strlen (reloc_name) + 8);
14670               if (more_info != NULL)
14671                 {
14672                   strcpy (more_info, reloc_name);
14673                   strcat (more_info, (reloc_dest == DEST_OPD
14674                                       ? " (OPD)" : " (stub)"));
14675                   reloc_name = more_info;
14676                 }
14677             }
14678
14679           if (r == bfd_reloc_overflow)
14680             {
14681               if (warned)
14682                 continue;
14683               if (h != NULL
14684                   && h->elf.root.type == bfd_link_hash_undefweak
14685                   && howto->pc_relative)
14686                 {
14687                   /* Assume this is a call protected by other code that
14688                      detects the symbol is undefined.  If this is the case,
14689                      we can safely ignore the overflow.  If not, the
14690                      program is hosed anyway, and a little warning isn't
14691                      going to help.  */
14692
14693                   continue;
14694                 }
14695
14696               if (!((*info->callbacks->reloc_overflow)
14697                     (info, &h->elf.root, sym_name,
14698                      reloc_name, orig_rel.r_addend,
14699                      input_bfd, input_section, rel->r_offset)))
14700                 return FALSE;
14701             }
14702           else
14703             {
14704               info->callbacks->einfo
14705                 (_("%P: %H: %s against `%T': error %d\n"),
14706                  input_bfd, input_section, rel->r_offset,
14707                  reloc_name, sym_name, (int) r);
14708               ret = FALSE;
14709             }
14710           if (more_info != NULL)
14711             free (more_info);
14712         }
14713     }
14714
14715   /* If we're emitting relocations, then shortly after this function
14716      returns, reloc offsets and addends for this section will be
14717      adjusted.  Worse, reloc symbol indices will be for the output
14718      file rather than the input.  Save a copy of the relocs for
14719      opd_entry_value.  */
14720   if (is_opd && (info->emitrelocations || info->relocatable))
14721     {
14722       bfd_size_type amt;
14723       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14724       rel = bfd_alloc (input_bfd, amt);
14725       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14726       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14727       if (rel == NULL)
14728         return FALSE;
14729       memcpy (rel, relocs, amt);
14730     }
14731   return ret;
14732 }
14733
14734 /* Adjust the value of any local symbols in opd sections.  */
14735
14736 static int
14737 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14738                               const char *name ATTRIBUTE_UNUSED,
14739                               Elf_Internal_Sym *elfsym,
14740                               asection *input_sec,
14741                               struct elf_link_hash_entry *h)
14742 {
14743   struct _opd_sec_data *opd;
14744   long adjust;
14745   bfd_vma value;
14746
14747   if (h != NULL)
14748     return 1;
14749
14750   opd = get_opd_info (input_sec);
14751   if (opd == NULL || opd->adjust == NULL)
14752     return 1;
14753
14754   value = elfsym->st_value - input_sec->output_offset;
14755   if (!info->relocatable)
14756     value -= input_sec->output_section->vma;
14757
14758   adjust = opd->adjust[value / 8];
14759   if (adjust == -1)
14760     return 2;
14761
14762   elfsym->st_value += adjust;
14763   return 1;
14764 }
14765
14766 /* Finish up dynamic symbol handling.  We set the contents of various
14767    dynamic sections here.  */
14768
14769 static bfd_boolean
14770 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14771                                  struct bfd_link_info *info,
14772                                  struct elf_link_hash_entry *h,
14773                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14774 {
14775   struct ppc_link_hash_table *htab;
14776   struct plt_entry *ent;
14777   Elf_Internal_Rela rela;
14778   bfd_byte *loc;
14779
14780   htab = ppc_hash_table (info);
14781   if (htab == NULL)
14782     return FALSE;
14783
14784   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14785     if (ent->plt.offset != (bfd_vma) -1)
14786       {
14787         /* This symbol has an entry in the procedure linkage
14788            table.  Set it up.  */
14789         if (!htab->elf.dynamic_sections_created
14790             || h->dynindx == -1)
14791           {
14792             BFD_ASSERT (h->type == STT_GNU_IFUNC
14793                         && h->def_regular
14794                         && (h->root.type == bfd_link_hash_defined
14795                             || h->root.type == bfd_link_hash_defweak));
14796             rela.r_offset = (htab->elf.iplt->output_section->vma
14797                              + htab->elf.iplt->output_offset
14798                              + ent->plt.offset);
14799             if (htab->opd_abi)
14800               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14801             else
14802               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14803             rela.r_addend = (h->root.u.def.value
14804                              + h->root.u.def.section->output_offset
14805                              + h->root.u.def.section->output_section->vma
14806                              + ent->addend);
14807             loc = (htab->elf.irelplt->contents
14808                    + (htab->elf.irelplt->reloc_count++
14809                       * sizeof (Elf64_External_Rela)));
14810           }
14811         else
14812           {
14813             rela.r_offset = (htab->elf.splt->output_section->vma
14814                              + htab->elf.splt->output_offset
14815                              + ent->plt.offset);
14816             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14817             rela.r_addend = ent->addend;
14818             loc = (htab->elf.srelplt->contents
14819                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14820                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14821           }
14822         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14823
14824         if (!htab->opd_abi)
14825           {
14826             if (!h->def_regular)
14827               {
14828                 /* Mark the symbol as undefined, rather than as
14829                    defined in glink.  Leave the value if there were
14830                    any relocations where pointer equality matters
14831                    (this is a clue for the dynamic linker, to make
14832                    function pointer comparisons work between an
14833                    application and shared library), otherwise set it
14834                    to zero.  */
14835                 sym->st_shndx = SHN_UNDEF;
14836                 if (!h->pointer_equality_needed)
14837                   sym->st_value = 0;
14838                 else if (!h->ref_regular_nonweak)
14839                   {
14840                     /* This breaks function pointer comparisons, but
14841                        that is better than breaking tests for a NULL
14842                        function pointer.  */
14843                     sym->st_value = 0;
14844                   }
14845               }
14846           }
14847       }
14848
14849   if (h->needs_copy)
14850     {
14851       /* This symbol needs a copy reloc.  Set it up.  */
14852
14853       if (h->dynindx == -1
14854           || (h->root.type != bfd_link_hash_defined
14855               && h->root.type != bfd_link_hash_defweak)
14856           || htab->relbss == NULL)
14857         abort ();
14858
14859       rela.r_offset = (h->root.u.def.value
14860                        + h->root.u.def.section->output_section->vma
14861                        + h->root.u.def.section->output_offset);
14862       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14863       rela.r_addend = 0;
14864       loc = htab->relbss->contents;
14865       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14866       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14867     }
14868
14869   return TRUE;
14870 }
14871
14872 /* Used to decide how to sort relocs in an optimal manner for the
14873    dynamic linker, before writing them out.  */
14874
14875 static enum elf_reloc_type_class
14876 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14877                             const asection *rel_sec,
14878                             const Elf_Internal_Rela *rela)
14879 {
14880   enum elf_ppc64_reloc_type r_type;
14881   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14882
14883   if (rel_sec == htab->elf.irelplt)
14884     return reloc_class_ifunc;
14885
14886   r_type = ELF64_R_TYPE (rela->r_info);
14887   switch (r_type)
14888     {
14889     case R_PPC64_RELATIVE:
14890       return reloc_class_relative;
14891     case R_PPC64_JMP_SLOT:
14892       return reloc_class_plt;
14893     case R_PPC64_COPY:
14894       return reloc_class_copy;
14895     default:
14896       return reloc_class_normal;
14897     }
14898 }
14899
14900 /* Finish up the dynamic sections.  */
14901
14902 static bfd_boolean
14903 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14904                                    struct bfd_link_info *info)
14905 {
14906   struct ppc_link_hash_table *htab;
14907   bfd *dynobj;
14908   asection *sdyn;
14909
14910   htab = ppc_hash_table (info);
14911   if (htab == NULL)
14912     return FALSE;
14913
14914   dynobj = htab->elf.dynobj;
14915   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14916
14917   if (htab->elf.dynamic_sections_created)
14918     {
14919       Elf64_External_Dyn *dyncon, *dynconend;
14920
14921       if (sdyn == NULL || htab->elf.sgot == NULL)
14922         abort ();
14923
14924       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14925       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14926       for (; dyncon < dynconend; dyncon++)
14927         {
14928           Elf_Internal_Dyn dyn;
14929           asection *s;
14930
14931           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14932
14933           switch (dyn.d_tag)
14934             {
14935             default:
14936               continue;
14937
14938             case DT_PPC64_GLINK:
14939               s = htab->glink;
14940               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14941               /* We stupidly defined DT_PPC64_GLINK to be the start
14942                  of glink rather than the first entry point, which is
14943                  what ld.so needs, and now have a bigger stub to
14944                  support automatic multiple TOCs.  */
14945               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14946               break;
14947
14948             case DT_PPC64_OPD:
14949               s = bfd_get_section_by_name (output_bfd, ".opd");
14950               if (s == NULL)
14951                 continue;
14952               dyn.d_un.d_ptr = s->vma;
14953               break;
14954
14955             case DT_PPC64_OPT:
14956               if (htab->do_multi_toc && htab->multi_toc_needed)
14957                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14958               break;
14959
14960             case DT_PPC64_OPDSZ:
14961               s = bfd_get_section_by_name (output_bfd, ".opd");
14962               if (s == NULL)
14963                 continue;
14964               dyn.d_un.d_val = s->size;
14965               break;
14966
14967             case DT_PLTGOT:
14968               s = htab->elf.splt;
14969               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14970               break;
14971
14972             case DT_JMPREL:
14973               s = htab->elf.srelplt;
14974               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14975               break;
14976
14977             case DT_PLTRELSZ:
14978               dyn.d_un.d_val = htab->elf.srelplt->size;
14979               break;
14980
14981             case DT_RELASZ:
14982               /* Don't count procedure linkage table relocs in the
14983                  overall reloc count.  */
14984               s = htab->elf.srelplt;
14985               if (s == NULL)
14986                 continue;
14987               dyn.d_un.d_val -= s->size;
14988               break;
14989
14990             case DT_RELA:
14991               /* We may not be using the standard ELF linker script.
14992                  If .rela.plt is the first .rela section, we adjust
14993                  DT_RELA to not include it.  */
14994               s = htab->elf.srelplt;
14995               if (s == NULL)
14996                 continue;
14997               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14998                 continue;
14999               dyn.d_un.d_ptr += s->size;
15000               break;
15001             }
15002
15003           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15004         }
15005     }
15006
15007   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15008     {
15009       /* Fill in the first entry in the global offset table.
15010          We use it to hold the link-time TOCbase.  */
15011       bfd_put_64 (output_bfd,
15012                   elf_gp (output_bfd) + TOC_BASE_OFF,
15013                   htab->elf.sgot->contents);
15014
15015       /* Set .got entry size.  */
15016       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15017     }
15018
15019   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15020     {
15021       /* Set .plt entry size.  */
15022       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15023         = PLT_ENTRY_SIZE (htab);
15024     }
15025
15026   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15027      brlt ourselves if emitrelocations.  */
15028   if (htab->brlt != NULL
15029       && htab->brlt->reloc_count != 0
15030       && !_bfd_elf_link_output_relocs (output_bfd,
15031                                        htab->brlt,
15032                                        elf_section_data (htab->brlt)->rela.hdr,
15033                                        elf_section_data (htab->brlt)->relocs,
15034                                        NULL))
15035     return FALSE;
15036
15037   if (htab->glink != NULL
15038       && htab->glink->reloc_count != 0
15039       && !_bfd_elf_link_output_relocs (output_bfd,
15040                                        htab->glink,
15041                                        elf_section_data (htab->glink)->rela.hdr,
15042                                        elf_section_data (htab->glink)->relocs,
15043                                        NULL))
15044     return FALSE;
15045
15046
15047   if (htab->glink_eh_frame != NULL
15048       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15049       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15050                                            htab->glink_eh_frame,
15051                                            htab->glink_eh_frame->contents))
15052     return FALSE;
15053
15054   /* We need to handle writing out multiple GOT sections ourselves,
15055      since we didn't add them to DYNOBJ.  We know dynobj is the first
15056      bfd.  */
15057   while ((dynobj = dynobj->link_next) != NULL)
15058     {
15059       asection *s;
15060
15061       if (!is_ppc64_elf (dynobj))
15062         continue;
15063
15064       s = ppc64_elf_tdata (dynobj)->got;
15065       if (s != NULL
15066           && s->size != 0
15067           && s->output_section != bfd_abs_section_ptr
15068           && !bfd_set_section_contents (output_bfd, s->output_section,
15069                                         s->contents, s->output_offset,
15070                                         s->size))
15071         return FALSE;
15072       s = ppc64_elf_tdata (dynobj)->relgot;
15073       if (s != NULL
15074           && s->size != 0
15075           && s->output_section != bfd_abs_section_ptr
15076           && !bfd_set_section_contents (output_bfd, s->output_section,
15077                                         s->contents, s->output_offset,
15078                                         s->size))
15079         return FALSE;
15080     }
15081
15082   return TRUE;
15083 }
15084
15085 #include "elf64-target.h"
15086
15087 /* FreeBSD support */
15088
15089 #undef  TARGET_LITTLE_SYM
15090 #undef  TARGET_LITTLE_NAME
15091
15092 #undef  TARGET_BIG_SYM
15093 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15094 #undef  TARGET_BIG_NAME
15095 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15096
15097 #undef  ELF_OSABI
15098 #define ELF_OSABI       ELFOSABI_FREEBSD
15099
15100 #undef  elf64_bed
15101 #define elf64_bed       elf64_powerpc_fbsd_bed
15102
15103 #include "elf64-target.h"
15104