bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2016 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      0x10000
  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_dtrel_excludes_plt 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  85 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  86 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  87 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  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 /* TOC base alignment.  */
 143 #define TOC_BASE_ALIGN  256
 144
 145 /* Offset of tp and dtp pointers from start of TLS block.  */
 146 #define TP_OFFSET       0x7000
 147 #define DTP_OFFSET      0x8000
 148
 149 /* .plt call stub instructions.  The normal stub is like this, but
 150    sometimes the .plt entry crosses a 64k boundary and we need to
 151    insert an addi to adjust r11.  */
 152 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 153 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 154 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 155 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 156 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 157 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 158 #define BCTR            0x4e800420      /* bctr                      */
 159
 160 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 161 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 162 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 163
 164 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 165 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 166 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 167 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 168 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 169 #define BNECTR          0x4ca20420      /* bnectr+               */
 170 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 171
 172 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 173 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 174 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 175
 176 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 177 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,0(%r12)     */
 178 #define ADD_R2_R2_R12   0x7c426214      /* add   %r2,%r2,%r12    */
 179
 180 #define LIS_R2          0x3c400000      /* lis %r2,xxx@ha         */
 181 #define ADDIS_R2_R12    0x3c4c0000      /* addis %r2,%r12,xxx@ha  */
 182 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha  */
 183 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 184 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 185
 186 /* glink call stub instructions.  We enter with the index in R0.  */
 187 #define GLINK_CALL_STUB_SIZE (16*4)
 188                                         /* 0:                           */
 189                                         /*  .quad plt0-1f               */
 190                                         /* __glink:                     */
 191 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 192 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 193                                         /* 1:                           */
 194 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 195                                         /*  ld %2,(0b-1b)(%11)          */
 196 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 197 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 198                                         /*  ld %12,0(%11)               */
 199                                         /*  ld %2,8(%11)                */
 200                                         /*  mtctr %12                   */
 201                                         /*  ld %11,16(%11)              */
 202                                         /*  bctr                        */
 203 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 204 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 205 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 206 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 207 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 208
 209 /* Pad with this.  */
 210 #define NOP             0x60000000
 211
 212 /* Some other nops.  */
 213 #define CROR_151515     0x4def7b82
 214 #define CROR_313131     0x4ffffb82
 215
 216 /* .glink entries for the first 32k functions are two instructions.  */
 217 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 218 #define B_DOT           0x48000000      /* b     .              */
 219
 220 /* After that, we need two instructions to load the index, followed by
 221    a branch.  */
 222 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 223 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 224
 225 /* Instructions used by the save and restore reg functions.  */
 226 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 227 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 228 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 229 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 230 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 231 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 232 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 233 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 234 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 235 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 236 #define BLR             0x4e800020      /* blr                  */
 237
 238 /* Since .opd is an array of descriptors and each entry will end up
 239    with identical R_PPC64_RELATIVE relocs, there is really no need to
 240    propagate .opd relocs;  The dynamic linker should be taught to
 241    relocate .opd without reloc entries.  */
 242 #ifndef NO_OPD_RELOCS
 243 #define NO_OPD_RELOCS 0
 244 #endif
 245
 246 #ifndef ARRAY_SIZE
 247 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 248 #endif
 249
 250 static inline int
 251 abiversion (bfd *abfd)
 252 {
 253   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 254 }
 255
 256 static inline void
 257 set_abiversion (bfd *abfd, int ver)
 258 {
 259   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 260   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 261 }
 262 \f
 263 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 264
 265 /* Relocation HOWTO's.  */
 266 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 267
 268 static reloc_howto_type ppc64_elf_howto_raw[] = {
 269   /* This reloc does nothing.  */
 270   HOWTO (R_PPC64_NONE,          /* type */
 271          0,                     /* rightshift */
 272          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 273          0,                     /* bitsize */
 274          FALSE,                 /* pc_relative */
 275          0,                     /* bitpos */
 276          complain_overflow_dont, /* complain_on_overflow */
 277          bfd_elf_generic_reloc, /* special_function */
 278          "R_PPC64_NONE",        /* name */
 279          FALSE,                 /* partial_inplace */
 280          0,                     /* src_mask */
 281          0,                     /* dst_mask */
 282          FALSE),                /* pcrel_offset */
 283
 284   /* A standard 32 bit relocation.  */
 285   HOWTO (R_PPC64_ADDR32,        /* type */
 286          0,                     /* rightshift */
 287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 288          32,                    /* bitsize */
 289          FALSE,                 /* pc_relative */
 290          0,                     /* bitpos */
 291          complain_overflow_bitfield, /* complain_on_overflow */
 292          bfd_elf_generic_reloc, /* special_function */
 293          "R_PPC64_ADDR32",      /* name */
 294          FALSE,                 /* partial_inplace */
 295          0,                     /* src_mask */
 296          0xffffffff,            /* dst_mask */
 297          FALSE),                /* pcrel_offset */
 298
 299   /* An absolute 26 bit branch; the lower two bits must be zero.
 300      FIXME: we don't check that, we just clear them.  */
 301   HOWTO (R_PPC64_ADDR24,        /* type */
 302          0,                     /* rightshift */
 303          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 304          26,                    /* bitsize */
 305          FALSE,                 /* pc_relative */
 306          0,                     /* bitpos */
 307          complain_overflow_bitfield, /* complain_on_overflow */
 308          bfd_elf_generic_reloc, /* special_function */
 309          "R_PPC64_ADDR24",      /* name */
 310          FALSE,                 /* partial_inplace */
 311          0,                     /* src_mask */
 312          0x03fffffc,            /* dst_mask */
 313          FALSE),                /* pcrel_offset */
 314
 315   /* A standard 16 bit relocation.  */
 316   HOWTO (R_PPC64_ADDR16,        /* type */
 317          0,                     /* rightshift */
 318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          16,                    /* bitsize */
 320          FALSE,                 /* pc_relative */
 321          0,                     /* bitpos */
 322          complain_overflow_bitfield, /* complain_on_overflow */
 323          bfd_elf_generic_reloc, /* special_function */
 324          "R_PPC64_ADDR16",      /* name */
 325          FALSE,                 /* partial_inplace */
 326          0,                     /* src_mask */
 327          0xffff,                /* dst_mask */
 328          FALSE),                /* pcrel_offset */
 329
 330   /* A 16 bit relocation without overflow.  */
 331   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 332          0,                     /* rightshift */
 333          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 334          16,                    /* bitsize */
 335          FALSE,                 /* pc_relative */
 336          0,                     /* bitpos */
 337          complain_overflow_dont,/* complain_on_overflow */
 338          bfd_elf_generic_reloc, /* special_function */
 339          "R_PPC64_ADDR16_LO",   /* name */
 340          FALSE,                 /* partial_inplace */
 341          0,                     /* src_mask */
 342          0xffff,                /* dst_mask */
 343          FALSE),                /* pcrel_offset */
 344
 345   /* Bits 16-31 of an address.  */
 346   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 347          16,                    /* rightshift */
 348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 349          16,                    /* bitsize */
 350          FALSE,                 /* pc_relative */
 351          0,                     /* bitpos */
 352          complain_overflow_signed, /* complain_on_overflow */
 353          bfd_elf_generic_reloc, /* special_function */
 354          "R_PPC64_ADDR16_HI",   /* name */
 355          FALSE,                 /* partial_inplace */
 356          0,                     /* src_mask */
 357          0xffff,                /* dst_mask */
 358          FALSE),                /* pcrel_offset */
 359
 360   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 361      bits, treated as a signed number, is negative.  */
 362   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 363          16,                    /* rightshift */
 364          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 365          16,                    /* bitsize */
 366          FALSE,                 /* pc_relative */
 367          0,                     /* bitpos */
 368          complain_overflow_signed, /* complain_on_overflow */
 369          ppc64_elf_ha_reloc,    /* special_function */
 370          "R_PPC64_ADDR16_HA",   /* name */
 371          FALSE,                 /* partial_inplace */
 372          0,                     /* src_mask */
 373          0xffff,                /* dst_mask */
 374          FALSE),                /* pcrel_offset */
 375
 376   /* An absolute 16 bit branch; the lower two bits must be zero.
 377      FIXME: we don't check that, we just clear them.  */
 378   HOWTO (R_PPC64_ADDR14,        /* type */
 379          0,                     /* rightshift */
 380          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 381          16,                    /* bitsize */
 382          FALSE,                 /* pc_relative */
 383          0,                     /* bitpos */
 384          complain_overflow_signed, /* complain_on_overflow */
 385          ppc64_elf_branch_reloc, /* special_function */
 386          "R_PPC64_ADDR14",      /* name */
 387          FALSE,                 /* partial_inplace */
 388          0,                     /* src_mask */
 389          0x0000fffc,            /* dst_mask */
 390          FALSE),                /* pcrel_offset */
 391
 392   /* An absolute 16 bit branch, for which bit 10 should be set to
 393      indicate that the branch is expected to be taken.  The lower two
 394      bits must be zero.  */
 395   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 396          0,                     /* rightshift */
 397          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 398          16,                    /* bitsize */
 399          FALSE,                 /* pc_relative */
 400          0,                     /* bitpos */
 401          complain_overflow_signed, /* complain_on_overflow */
 402          ppc64_elf_brtaken_reloc, /* special_function */
 403          "R_PPC64_ADDR14_BRTAKEN",/* name */
 404          FALSE,                 /* partial_inplace */
 405          0,                     /* src_mask */
 406          0x0000fffc,            /* dst_mask */
 407          FALSE),                /* pcrel_offset */
 408
 409   /* An absolute 16 bit branch, for which bit 10 should be set to
 410      indicate that the branch is not expected to be taken.  The lower
 411      two bits must be zero.  */
 412   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 413          0,                     /* rightshift */
 414          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 415          16,                    /* bitsize */
 416          FALSE,                 /* pc_relative */
 417          0,                     /* bitpos */
 418          complain_overflow_signed, /* complain_on_overflow */
 419          ppc64_elf_brtaken_reloc, /* special_function */
 420          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 421          FALSE,                 /* partial_inplace */
 422          0,                     /* src_mask */
 423          0x0000fffc,            /* dst_mask */
 424          FALSE),                /* pcrel_offset */
 425
 426   /* A relative 26 bit branch; the lower two bits must be zero.  */
 427   HOWTO (R_PPC64_REL24,         /* type */
 428          0,                     /* rightshift */
 429          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 430          26,                    /* bitsize */
 431          TRUE,                  /* pc_relative */
 432          0,                     /* bitpos */
 433          complain_overflow_signed, /* complain_on_overflow */
 434          ppc64_elf_branch_reloc, /* special_function */
 435          "R_PPC64_REL24",       /* name */
 436          FALSE,                 /* partial_inplace */
 437          0,                     /* src_mask */
 438          0x03fffffc,            /* dst_mask */
 439          TRUE),                 /* pcrel_offset */
 440
 441   /* A relative 16 bit branch; the lower two bits must be zero.  */
 442   HOWTO (R_PPC64_REL14,         /* type */
 443          0,                     /* rightshift */
 444          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 445          16,                    /* bitsize */
 446          TRUE,                  /* pc_relative */
 447          0,                     /* bitpos */
 448          complain_overflow_signed, /* complain_on_overflow */
 449          ppc64_elf_branch_reloc, /* special_function */
 450          "R_PPC64_REL14",       /* name */
 451          FALSE,                 /* partial_inplace */
 452          0,                     /* src_mask */
 453          0x0000fffc,            /* dst_mask */
 454          TRUE),                 /* pcrel_offset */
 455
 456   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 457      the branch is expected to be taken.  The lower two bits must be
 458      zero.  */
 459   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 460          0,                     /* rightshift */
 461          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 462          16,                    /* bitsize */
 463          TRUE,                  /* pc_relative */
 464          0,                     /* bitpos */
 465          complain_overflow_signed, /* complain_on_overflow */
 466          ppc64_elf_brtaken_reloc, /* special_function */
 467          "R_PPC64_REL14_BRTAKEN", /* name */
 468          FALSE,                 /* partial_inplace */
 469          0,                     /* src_mask */
 470          0x0000fffc,            /* dst_mask */
 471          TRUE),                 /* pcrel_offset */
 472
 473   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 474      the branch is not expected to be taken.  The lower two bits must
 475      be zero.  */
 476   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 477          0,                     /* rightshift */
 478          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          16,                    /* bitsize */
 480          TRUE,                  /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_signed, /* complain_on_overflow */
 483          ppc64_elf_brtaken_reloc, /* special_function */
 484          "R_PPC64_REL14_BRNTAKEN",/* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0x0000fffc,            /* dst_mask */
 488          TRUE),                 /* pcrel_offset */
 489
 490   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 491      symbol.  */
 492   HOWTO (R_PPC64_GOT16,         /* type */
 493          0,                     /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          16,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_signed, /* complain_on_overflow */
 499          ppc64_elf_unhandled_reloc, /* special_function */
 500          "R_PPC64_GOT16",       /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          0xffff,                /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 507      the symbol.  */
 508   HOWTO (R_PPC64_GOT16_LO,      /* type */
 509          0,                     /* rightshift */
 510          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          16,                    /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_GOT16_LO",    /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0xffff,                /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 523      the symbol.  */
 524   HOWTO (R_PPC64_GOT16_HI,      /* type */
 525          16,                    /* rightshift */
 526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 527          16,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_signed,/* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc, /* special_function */
 532          "R_PPC64_GOT16_HI",    /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          0xffff,                /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 539      the symbol.  */
 540   HOWTO (R_PPC64_GOT16_HA,      /* type */
 541          16,                    /* rightshift */
 542          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          16,                    /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_signed,/* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_GOT16_HA",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0xffff,                /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* This is used only by the dynamic linker.  The symbol should exist
 555      both in the object being run and in some shared library.  The
 556      dynamic linker copies the data addressed by the symbol from the
 557      shared library into the object, because the object being
 558      run has to have the data at some particular address.  */
 559   HOWTO (R_PPC64_COPY,          /* type */
 560          0,                     /* rightshift */
 561          0,                     /* this one is variable size */
 562          0,                     /* bitsize */
 563          FALSE,                 /* pc_relative */
 564          0,                     /* bitpos */
 565          complain_overflow_dont, /* complain_on_overflow */
 566          ppc64_elf_unhandled_reloc, /* special_function */
 567          "R_PPC64_COPY",        /* name */
 568          FALSE,                 /* partial_inplace */
 569          0,                     /* src_mask */
 570          0,                     /* dst_mask */
 571          FALSE),                /* pcrel_offset */
 572
 573   /* Like R_PPC64_ADDR64, but used when setting global offset table
 574      entries.  */
 575   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 576          0,                     /* rightshift */
 577          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 578          64,                    /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          0,                     /* bitpos */
 581          complain_overflow_dont, /* complain_on_overflow */
 582          ppc64_elf_unhandled_reloc,  /* special_function */
 583          "R_PPC64_GLOB_DAT",    /* name */
 584          FALSE,                 /* partial_inplace */
 585          0,                     /* src_mask */
 586          ONES (64),             /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   /* Created by the link editor.  Marks a procedure linkage table
 590      entry for a symbol.  */
 591   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 592          0,                     /* rightshift */
 593          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 594          0,                     /* bitsize */
 595          FALSE,                 /* pc_relative */
 596          0,                     /* bitpos */
 597          complain_overflow_dont, /* complain_on_overflow */
 598          ppc64_elf_unhandled_reloc, /* special_function */
 599          "R_PPC64_JMP_SLOT",    /* name */
 600          FALSE,                 /* partial_inplace */
 601          0,                     /* src_mask */
 602          0,                     /* dst_mask */
 603          FALSE),                /* pcrel_offset */
 604
 605   /* Used only by the dynamic linker.  When the object is run, this
 606      doubleword64 is set to the load address of the object, plus the
 607      addend.  */
 608   HOWTO (R_PPC64_RELATIVE,      /* type */
 609          0,                     /* rightshift */
 610          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 611          64,                    /* bitsize */
 612          FALSE,                 /* pc_relative */
 613          0,                     /* bitpos */
 614          complain_overflow_dont, /* complain_on_overflow */
 615          bfd_elf_generic_reloc, /* special_function */
 616          "R_PPC64_RELATIVE",    /* name */
 617          FALSE,                 /* partial_inplace */
 618          0,                     /* src_mask */
 619          ONES (64),             /* dst_mask */
 620          FALSE),                /* pcrel_offset */
 621
 622   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 623   HOWTO (R_PPC64_UADDR32,       /* type */
 624          0,                     /* rightshift */
 625          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 626          32,                    /* bitsize */
 627          FALSE,                 /* pc_relative */
 628          0,                     /* bitpos */
 629          complain_overflow_bitfield, /* complain_on_overflow */
 630          bfd_elf_generic_reloc, /* special_function */
 631          "R_PPC64_UADDR32",     /* name */
 632          FALSE,                 /* partial_inplace */
 633          0,                     /* src_mask */
 634          0xffffffff,            /* dst_mask */
 635          FALSE),                /* pcrel_offset */
 636
 637   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 638   HOWTO (R_PPC64_UADDR16,       /* type */
 639          0,                     /* rightshift */
 640          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 641          16,                    /* bitsize */
 642          FALSE,                 /* pc_relative */
 643          0,                     /* bitpos */
 644          complain_overflow_bitfield, /* complain_on_overflow */
 645          bfd_elf_generic_reloc, /* special_function */
 646          "R_PPC64_UADDR16",     /* name */
 647          FALSE,                 /* partial_inplace */
 648          0,                     /* src_mask */
 649          0xffff,                /* dst_mask */
 650          FALSE),                /* pcrel_offset */
 651
 652   /* 32-bit PC relative.  */
 653   HOWTO (R_PPC64_REL32,         /* type */
 654          0,                     /* rightshift */
 655          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          32,                    /* bitsize */
 657          TRUE,                  /* pc_relative */
 658          0,                     /* bitpos */
 659          complain_overflow_signed, /* complain_on_overflow */
 660          bfd_elf_generic_reloc, /* special_function */
 661          "R_PPC64_REL32",       /* name */
 662          FALSE,                 /* partial_inplace */
 663          0,                     /* src_mask */
 664          0xffffffff,            /* dst_mask */
 665          TRUE),                 /* pcrel_offset */
 666
 667   /* 32-bit relocation to the symbol's procedure linkage table.  */
 668   HOWTO (R_PPC64_PLT32,         /* type */
 669          0,                     /* rightshift */
 670          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 671          32,                    /* bitsize */
 672          FALSE,                 /* pc_relative */
 673          0,                     /* bitpos */
 674          complain_overflow_bitfield, /* complain_on_overflow */
 675          ppc64_elf_unhandled_reloc, /* special_function */
 676          "R_PPC64_PLT32",       /* name */
 677          FALSE,                 /* partial_inplace */
 678          0,                     /* src_mask */
 679          0xffffffff,            /* dst_mask */
 680          FALSE),                /* pcrel_offset */
 681
 682   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 683      FIXME: R_PPC64_PLTREL32 not supported.  */
 684   HOWTO (R_PPC64_PLTREL32,      /* type */
 685          0,                     /* rightshift */
 686          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 687          32,                    /* bitsize */
 688          TRUE,                  /* pc_relative */
 689          0,                     /* bitpos */
 690          complain_overflow_signed, /* complain_on_overflow */
 691          ppc64_elf_unhandled_reloc, /* special_function */
 692          "R_PPC64_PLTREL32",    /* name */
 693          FALSE,                 /* partial_inplace */
 694          0,                     /* src_mask */
 695          0xffffffff,            /* dst_mask */
 696          TRUE),                 /* pcrel_offset */
 697
 698   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 699      the symbol.  */
 700   HOWTO (R_PPC64_PLT16_LO,      /* type */
 701          0,                     /* rightshift */
 702          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          16,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_dont, /* complain_on_overflow */
 707          ppc64_elf_unhandled_reloc, /* special_function */
 708          "R_PPC64_PLT16_LO",    /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffff,                /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 715      the symbol.  */
 716   HOWTO (R_PPC64_PLT16_HI,      /* type */
 717          16,                    /* rightshift */
 718          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 719          16,                    /* bitsize */
 720          FALSE,                 /* pc_relative */
 721          0,                     /* bitpos */
 722          complain_overflow_signed, /* complain_on_overflow */
 723          ppc64_elf_unhandled_reloc, /* special_function */
 724          "R_PPC64_PLT16_HI",    /* name */
 725          FALSE,                 /* partial_inplace */
 726          0,                     /* src_mask */
 727          0xffff,                /* dst_mask */
 728          FALSE),                /* pcrel_offset */
 729
 730   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 731      the symbol.  */
 732   HOWTO (R_PPC64_PLT16_HA,      /* type */
 733          16,                    /* rightshift */
 734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 735          16,                    /* bitsize */
 736          FALSE,                 /* pc_relative */
 737          0,                     /* bitpos */
 738          complain_overflow_signed, /* complain_on_overflow */
 739          ppc64_elf_unhandled_reloc, /* special_function */
 740          "R_PPC64_PLT16_HA",    /* name */
 741          FALSE,                 /* partial_inplace */
 742          0,                     /* src_mask */
 743          0xffff,                /* dst_mask */
 744          FALSE),                /* pcrel_offset */
 745
 746   /* 16-bit section relative relocation.  */
 747   HOWTO (R_PPC64_SECTOFF,       /* type */
 748          0,                     /* rightshift */
 749          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 750          16,                    /* bitsize */
 751          FALSE,                 /* pc_relative */
 752          0,                     /* bitpos */
 753          complain_overflow_signed, /* complain_on_overflow */
 754          ppc64_elf_sectoff_reloc, /* special_function */
 755          "R_PPC64_SECTOFF",     /* name */
 756          FALSE,                 /* partial_inplace */
 757          0,                     /* src_mask */
 758          0xffff,                /* dst_mask */
 759          FALSE),                /* pcrel_offset */
 760
 761   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 762   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 763          0,                     /* rightshift */
 764          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 765          16,                    /* bitsize */
 766          FALSE,                 /* pc_relative */
 767          0,                     /* bitpos */
 768          complain_overflow_dont, /* complain_on_overflow */
 769          ppc64_elf_sectoff_reloc, /* special_function */
 770          "R_PPC64_SECTOFF_LO",  /* name */
 771          FALSE,                 /* partial_inplace */
 772          0,                     /* src_mask */
 773          0xffff,                /* dst_mask */
 774          FALSE),                /* pcrel_offset */
 775
 776   /* 16-bit upper half section relative relocation.  */
 777   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 778          16,                    /* rightshift */
 779          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 780          16,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_signed, /* complain_on_overflow */
 784          ppc64_elf_sectoff_reloc, /* special_function */
 785          "R_PPC64_SECTOFF_HI",  /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          0xffff,                /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   /* 16-bit upper half adjusted section relative relocation.  */
 792   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 793          16,                    /* rightshift */
 794          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          FALSE,                 /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_signed, /* complain_on_overflow */
 799          ppc64_elf_sectoff_ha_reloc, /* special_function */
 800          "R_PPC64_SECTOFF_HA",  /* name */
 801          FALSE,                 /* partial_inplace */
 802          0,                     /* src_mask */
 803          0xffff,                /* dst_mask */
 804          FALSE),                /* pcrel_offset */
 805
 806   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 807   HOWTO (R_PPC64_REL30,         /* type */
 808          2,                     /* rightshift */
 809          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 810          30,                    /* bitsize */
 811          TRUE,                  /* pc_relative */
 812          0,                     /* bitpos */
 813          complain_overflow_dont, /* complain_on_overflow */
 814          bfd_elf_generic_reloc, /* special_function */
 815          "R_PPC64_REL30",       /* name */
 816          FALSE,                 /* partial_inplace */
 817          0,                     /* src_mask */
 818          0xfffffffc,            /* dst_mask */
 819          TRUE),                 /* pcrel_offset */
 820
 821   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 822
 823   /* A standard 64-bit relocation.  */
 824   HOWTO (R_PPC64_ADDR64,        /* type */
 825          0,                     /* rightshift */
 826          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 827          64,                    /* bitsize */
 828          FALSE,                 /* pc_relative */
 829          0,                     /* bitpos */
 830          complain_overflow_dont, /* complain_on_overflow */
 831          bfd_elf_generic_reloc, /* special_function */
 832          "R_PPC64_ADDR64",      /* name */
 833          FALSE,                 /* partial_inplace */
 834          0,                     /* src_mask */
 835          ONES (64),             /* dst_mask */
 836          FALSE),                /* pcrel_offset */
 837
 838   /* The bits 32-47 of an address.  */
 839   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 840          32,                    /* rightshift */
 841          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 842          16,                    /* bitsize */
 843          FALSE,                 /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          bfd_elf_generic_reloc, /* special_function */
 847          "R_PPC64_ADDR16_HIGHER", /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          0xffff,                /* dst_mask */
 851          FALSE),                /* pcrel_offset */
 852
 853   /* The bits 32-47 of an address, plus 1 if the contents of the low
 854      16 bits, treated as a signed number, is negative.  */
 855   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 856          32,                    /* rightshift */
 857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 858          16,                    /* bitsize */
 859          FALSE,                 /* pc_relative */
 860          0,                     /* bitpos */
 861          complain_overflow_dont, /* complain_on_overflow */
 862          ppc64_elf_ha_reloc,    /* special_function */
 863          "R_PPC64_ADDR16_HIGHERA", /* name */
 864          FALSE,                 /* partial_inplace */
 865          0,                     /* src_mask */
 866          0xffff,                /* dst_mask */
 867          FALSE),                /* pcrel_offset */
 868
 869   /* The bits 48-63 of an address.  */
 870   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 871          48,                    /* rightshift */
 872          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 873          16,                    /* bitsize */
 874          FALSE,                 /* pc_relative */
 875          0,                     /* bitpos */
 876          complain_overflow_dont, /* complain_on_overflow */
 877          bfd_elf_generic_reloc, /* special_function */
 878          "R_PPC64_ADDR16_HIGHEST", /* name */
 879          FALSE,                 /* partial_inplace */
 880          0,                     /* src_mask */
 881          0xffff,                /* dst_mask */
 882          FALSE),                /* pcrel_offset */
 883
 884   /* The bits 48-63 of an address, plus 1 if the contents of the low
 885      16 bits, treated as a signed number, is negative.  */
 886   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 887          48,                    /* rightshift */
 888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 889          16,                    /* bitsize */
 890          FALSE,                 /* pc_relative */
 891          0,                     /* bitpos */
 892          complain_overflow_dont, /* complain_on_overflow */
 893          ppc64_elf_ha_reloc,    /* special_function */
 894          "R_PPC64_ADDR16_HIGHESTA", /* name */
 895          FALSE,                 /* partial_inplace */
 896          0,                     /* src_mask */
 897          0xffff,                /* dst_mask */
 898          FALSE),                /* pcrel_offset */
 899
 900   /* Like ADDR64, but may be unaligned.  */
 901   HOWTO (R_PPC64_UADDR64,       /* type */
 902          0,                     /* rightshift */
 903          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 904          64,                    /* bitsize */
 905          FALSE,                 /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_dont, /* complain_on_overflow */
 908          bfd_elf_generic_reloc, /* special_function */
 909          "R_PPC64_UADDR64",     /* name */
 910          FALSE,                 /* partial_inplace */
 911          0,                     /* src_mask */
 912          ONES (64),             /* dst_mask */
 913          FALSE),                /* pcrel_offset */
 914
 915   /* 64-bit relative relocation.  */
 916   HOWTO (R_PPC64_REL64,         /* type */
 917          0,                     /* rightshift */
 918          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 919          64,                    /* bitsize */
 920          TRUE,                  /* pc_relative */
 921          0,                     /* bitpos */
 922          complain_overflow_dont, /* complain_on_overflow */
 923          bfd_elf_generic_reloc, /* special_function */
 924          "R_PPC64_REL64",       /* name */
 925          FALSE,                 /* partial_inplace */
 926          0,                     /* src_mask */
 927          ONES (64),             /* dst_mask */
 928          TRUE),                 /* pcrel_offset */
 929
 930   /* 64-bit relocation to the symbol's procedure linkage table.  */
 931   HOWTO (R_PPC64_PLT64,         /* type */
 932          0,                     /* rightshift */
 933          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 934          64,                    /* bitsize */
 935          FALSE,                 /* pc_relative */
 936          0,                     /* bitpos */
 937          complain_overflow_dont, /* complain_on_overflow */
 938          ppc64_elf_unhandled_reloc, /* special_function */
 939          "R_PPC64_PLT64",       /* name */
 940          FALSE,                 /* partial_inplace */
 941          0,                     /* src_mask */
 942          ONES (64),             /* dst_mask */
 943          FALSE),                /* pcrel_offset */
 944
 945   /* 64-bit PC relative relocation to the symbol's procedure linkage
 946      table.  */
 947   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 948   HOWTO (R_PPC64_PLTREL64,      /* type */
 949          0,                     /* rightshift */
 950          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 951          64,                    /* bitsize */
 952          TRUE,                  /* pc_relative */
 953          0,                     /* bitpos */
 954          complain_overflow_dont, /* complain_on_overflow */
 955          ppc64_elf_unhandled_reloc, /* special_function */
 956          "R_PPC64_PLTREL64",    /* name */
 957          FALSE,                 /* partial_inplace */
 958          0,                     /* src_mask */
 959          ONES (64),             /* dst_mask */
 960          TRUE),                 /* pcrel_offset */
 961
 962   /* 16 bit TOC-relative relocation.  */
 963
 964   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 965   HOWTO (R_PPC64_TOC16,         /* type */
 966          0,                     /* rightshift */
 967          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 968          16,                    /* bitsize */
 969          FALSE,                 /* pc_relative */
 970          0,                     /* bitpos */
 971          complain_overflow_signed, /* complain_on_overflow */
 972          ppc64_elf_toc_reloc,   /* special_function */
 973          "R_PPC64_TOC16",       /* name */
 974          FALSE,                 /* partial_inplace */
 975          0,                     /* src_mask */
 976          0xffff,                /* dst_mask */
 977          FALSE),                /* pcrel_offset */
 978
 979   /* 16 bit TOC-relative relocation without overflow.  */
 980
 981   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 982   HOWTO (R_PPC64_TOC16_LO,      /* type */
 983          0,                     /* rightshift */
 984          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 985          16,                    /* bitsize */
 986          FALSE,                 /* pc_relative */
 987          0,                     /* bitpos */
 988          complain_overflow_dont, /* complain_on_overflow */
 989          ppc64_elf_toc_reloc,   /* special_function */
 990          "R_PPC64_TOC16_LO",    /* name */
 991          FALSE,                 /* partial_inplace */
 992          0,                     /* src_mask */
 993          0xffff,                /* dst_mask */
 994          FALSE),                /* pcrel_offset */
 995
 996   /* 16 bit TOC-relative relocation, high 16 bits.  */
 997
 998   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 999   HOWTO (R_PPC64_TOC16_HI,      /* type */
1000          16,                    /* rightshift */
1001          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1002          16,                    /* bitsize */
1003          FALSE,                 /* pc_relative */
1004          0,                     /* bitpos */
1005          complain_overflow_signed, /* complain_on_overflow */
1006          ppc64_elf_toc_reloc,   /* special_function */
1007          "R_PPC64_TOC16_HI",    /* name */
1008          FALSE,                 /* partial_inplace */
1009          0,                     /* src_mask */
1010          0xffff,                /* dst_mask */
1011          FALSE),                /* pcrel_offset */
1012
1013   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1014      contents of the low 16 bits, treated as a signed number, is
1015      negative.  */
1016
1017   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1018   HOWTO (R_PPC64_TOC16_HA,      /* type */
1019          16,                    /* rightshift */
1020          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1021          16,                    /* bitsize */
1022          FALSE,                 /* pc_relative */
1023          0,                     /* bitpos */
1024          complain_overflow_signed, /* complain_on_overflow */
1025          ppc64_elf_toc_ha_reloc, /* special_function */
1026          "R_PPC64_TOC16_HA",    /* name */
1027          FALSE,                 /* partial_inplace */
1028          0,                     /* src_mask */
1029          0xffff,                /* dst_mask */
1030          FALSE),                /* pcrel_offset */
1031
1032   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1033
1034   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1035   HOWTO (R_PPC64_TOC,           /* type */
1036          0,                     /* rightshift */
1037          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1038          64,                    /* bitsize */
1039          FALSE,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_dont, /* complain_on_overflow */
1042          ppc64_elf_toc64_reloc, /* special_function */
1043          "R_PPC64_TOC",         /* name */
1044          FALSE,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          ONES (64),             /* dst_mask */
1047          FALSE),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_GOT16, but also informs the link editor that the
1050      value to relocate may (!) refer to a PLT entry which the link
1051      editor (a) may replace with the symbol value.  If the link editor
1052      is unable to fully resolve the symbol, it may (b) create a PLT
1053      entry and store the address to the new PLT entry in the GOT.
1054      This permits lazy resolution of function symbols at run time.
1055      The link editor may also skip all of this and just (c) emit a
1056      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1057   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1058     HOWTO (R_PPC64_PLTGOT16,    /* type */
1059          0,                     /* rightshift */
1060          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1061          16,                    /* bitsize */
1062          FALSE,                 /* pc_relative */
1063          0,                     /* bitpos */
1064          complain_overflow_signed, /* complain_on_overflow */
1065          ppc64_elf_unhandled_reloc, /* special_function */
1066          "R_PPC64_PLTGOT16",    /* name */
1067          FALSE,                 /* partial_inplace */
1068          0,                     /* src_mask */
1069          0xffff,                /* dst_mask */
1070          FALSE),                /* pcrel_offset */
1071
1072   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1073   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1074   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1075          0,                     /* rightshift */
1076          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1077          16,                    /* bitsize */
1078          FALSE,                 /* pc_relative */
1079          0,                     /* bitpos */
1080          complain_overflow_dont, /* complain_on_overflow */
1081          ppc64_elf_unhandled_reloc, /* special_function */
1082          "R_PPC64_PLTGOT16_LO", /* name */
1083          FALSE,                 /* partial_inplace */
1084          0,                     /* src_mask */
1085          0xffff,                /* dst_mask */
1086          FALSE),                /* pcrel_offset */
1087
1088   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1089   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1090   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1091          16,                    /* rightshift */
1092          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1093          16,                    /* bitsize */
1094          FALSE,                 /* pc_relative */
1095          0,                     /* bitpos */
1096          complain_overflow_signed, /* complain_on_overflow */
1097          ppc64_elf_unhandled_reloc, /* special_function */
1098          "R_PPC64_PLTGOT16_HI", /* name */
1099          FALSE,                 /* partial_inplace */
1100          0,                     /* src_mask */
1101          0xffff,                /* dst_mask */
1102          FALSE),                /* pcrel_offset */
1103
1104   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1105      1 if the contents of the low 16 bits, treated as a signed number,
1106      is negative.  */
1107   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1108   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1109          16,                    /* rightshift */
1110          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1111          16,                    /* bitsize */
1112          FALSE,                 /* pc_relative */
1113          0,                     /* bitpos */
1114          complain_overflow_signed, /* complain_on_overflow */
1115          ppc64_elf_unhandled_reloc, /* special_function */
1116          "R_PPC64_PLTGOT16_HA", /* name */
1117          FALSE,                 /* partial_inplace */
1118          0,                     /* src_mask */
1119          0xffff,                /* dst_mask */
1120          FALSE),                /* pcrel_offset */
1121
1122   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1123   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1124          0,                     /* rightshift */
1125          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1126          16,                    /* bitsize */
1127          FALSE,                 /* pc_relative */
1128          0,                     /* bitpos */
1129          complain_overflow_signed, /* complain_on_overflow */
1130          bfd_elf_generic_reloc, /* special_function */
1131          "R_PPC64_ADDR16_DS",   /* name */
1132          FALSE,                 /* partial_inplace */
1133          0,                     /* src_mask */
1134          0xfffc,                /* dst_mask */
1135          FALSE),                /* pcrel_offset */
1136
1137   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1138   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1139          0,                     /* rightshift */
1140          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1141          16,                    /* bitsize */
1142          FALSE,                 /* pc_relative */
1143          0,                     /* bitpos */
1144          complain_overflow_dont,/* complain_on_overflow */
1145          bfd_elf_generic_reloc, /* special_function */
1146          "R_PPC64_ADDR16_LO_DS",/* name */
1147          FALSE,                 /* partial_inplace */
1148          0,                     /* src_mask */
1149          0xfffc,                /* dst_mask */
1150          FALSE),                /* pcrel_offset */
1151
1152   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1153   HOWTO (R_PPC64_GOT16_DS,      /* type */
1154          0,                     /* rightshift */
1155          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1156          16,                    /* bitsize */
1157          FALSE,                 /* pc_relative */
1158          0,                     /* bitpos */
1159          complain_overflow_signed, /* complain_on_overflow */
1160          ppc64_elf_unhandled_reloc, /* special_function */
1161          "R_PPC64_GOT16_DS",    /* name */
1162          FALSE,                 /* partial_inplace */
1163          0,                     /* src_mask */
1164          0xfffc,                /* dst_mask */
1165          FALSE),                /* pcrel_offset */
1166
1167   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1168   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1169          0,                     /* rightshift */
1170          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1171          16,                    /* bitsize */
1172          FALSE,                 /* pc_relative */
1173          0,                     /* bitpos */
1174          complain_overflow_dont, /* complain_on_overflow */
1175          ppc64_elf_unhandled_reloc, /* special_function */
1176          "R_PPC64_GOT16_LO_DS", /* name */
1177          FALSE,                 /* partial_inplace */
1178          0,                     /* src_mask */
1179          0xfffc,                /* dst_mask */
1180          FALSE),                /* pcrel_offset */
1181
1182   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1183   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1184          0,                     /* rightshift */
1185          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1186          16,                    /* bitsize */
1187          FALSE,                 /* pc_relative */
1188          0,                     /* bitpos */
1189          complain_overflow_dont, /* complain_on_overflow */
1190          ppc64_elf_unhandled_reloc, /* special_function */
1191          "R_PPC64_PLT16_LO_DS", /* name */
1192          FALSE,                 /* partial_inplace */
1193          0,                     /* src_mask */
1194          0xfffc,                /* dst_mask */
1195          FALSE),                /* pcrel_offset */
1196
1197   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1198   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1199          0,                     /* rightshift */
1200          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1201          16,                    /* bitsize */
1202          FALSE,                 /* pc_relative */
1203          0,                     /* bitpos */
1204          complain_overflow_signed, /* complain_on_overflow */
1205          ppc64_elf_sectoff_reloc, /* special_function */
1206          "R_PPC64_SECTOFF_DS",  /* name */
1207          FALSE,                 /* partial_inplace */
1208          0,                     /* src_mask */
1209          0xfffc,                /* dst_mask */
1210          FALSE),                /* pcrel_offset */
1211
1212   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1213   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1214          0,                     /* rightshift */
1215          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1216          16,                    /* bitsize */
1217          FALSE,                 /* pc_relative */
1218          0,                     /* bitpos */
1219          complain_overflow_dont, /* complain_on_overflow */
1220          ppc64_elf_sectoff_reloc, /* special_function */
1221          "R_PPC64_SECTOFF_LO_DS",/* name */
1222          FALSE,                 /* partial_inplace */
1223          0,                     /* src_mask */
1224          0xfffc,                /* dst_mask */
1225          FALSE),                /* pcrel_offset */
1226
1227   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1228   HOWTO (R_PPC64_TOC16_DS,      /* type */
1229          0,                     /* rightshift */
1230          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1231          16,                    /* bitsize */
1232          FALSE,                 /* pc_relative */
1233          0,                     /* bitpos */
1234          complain_overflow_signed, /* complain_on_overflow */
1235          ppc64_elf_toc_reloc,   /* special_function */
1236          "R_PPC64_TOC16_DS",    /* name */
1237          FALSE,                 /* partial_inplace */
1238          0,                     /* src_mask */
1239          0xfffc,                /* dst_mask */
1240          FALSE),                /* pcrel_offset */
1241
1242   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1243   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1244          0,                     /* rightshift */
1245          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1246          16,                    /* bitsize */
1247          FALSE,                 /* pc_relative */
1248          0,                     /* bitpos */
1249          complain_overflow_dont, /* complain_on_overflow */
1250          ppc64_elf_toc_reloc,   /* special_function */
1251          "R_PPC64_TOC16_LO_DS", /* name */
1252          FALSE,                 /* partial_inplace */
1253          0,                     /* src_mask */
1254          0xfffc,                /* dst_mask */
1255          FALSE),                /* pcrel_offset */
1256
1257   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1258   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1259   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1260          0,                     /* rightshift */
1261          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1262          16,                    /* bitsize */
1263          FALSE,                 /* pc_relative */
1264          0,                     /* bitpos */
1265          complain_overflow_signed, /* complain_on_overflow */
1266          ppc64_elf_unhandled_reloc, /* special_function */
1267          "R_PPC64_PLTGOT16_DS", /* name */
1268          FALSE,                 /* partial_inplace */
1269          0,                     /* src_mask */
1270          0xfffc,                /* dst_mask */
1271          FALSE),                /* pcrel_offset */
1272
1273   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1274   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1275   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1276          0,                     /* rightshift */
1277          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1278          16,                    /* bitsize */
1279          FALSE,                 /* pc_relative */
1280          0,                     /* bitpos */
1281          complain_overflow_dont, /* complain_on_overflow */
1282          ppc64_elf_unhandled_reloc, /* special_function */
1283          "R_PPC64_PLTGOT16_LO_DS",/* name */
1284          FALSE,                 /* partial_inplace */
1285          0,                     /* src_mask */
1286          0xfffc,                /* dst_mask */
1287          FALSE),                /* pcrel_offset */
1288
1289   /* Marker relocs for TLS.  */
1290   HOWTO (R_PPC64_TLS,
1291          0,                     /* rightshift */
1292          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1293          32,                    /* bitsize */
1294          FALSE,                 /* pc_relative */
1295          0,                     /* bitpos */
1296          complain_overflow_dont, /* complain_on_overflow */
1297          bfd_elf_generic_reloc, /* special_function */
1298          "R_PPC64_TLS",         /* name */
1299          FALSE,                 /* partial_inplace */
1300          0,                     /* src_mask */
1301          0,                     /* dst_mask */
1302          FALSE),                /* pcrel_offset */
1303
1304   HOWTO (R_PPC64_TLSGD,
1305          0,                     /* rightshift */
1306          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1307          32,                    /* bitsize */
1308          FALSE,                 /* pc_relative */
1309          0,                     /* bitpos */
1310          complain_overflow_dont, /* complain_on_overflow */
1311          bfd_elf_generic_reloc, /* special_function */
1312          "R_PPC64_TLSGD",       /* name */
1313          FALSE,                 /* partial_inplace */
1314          0,                     /* src_mask */
1315          0,                     /* dst_mask */
1316          FALSE),                /* pcrel_offset */
1317
1318   HOWTO (R_PPC64_TLSLD,
1319          0,                     /* rightshift */
1320          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1321          32,                    /* bitsize */
1322          FALSE,                 /* pc_relative */
1323          0,                     /* bitpos */
1324          complain_overflow_dont, /* complain_on_overflow */
1325          bfd_elf_generic_reloc, /* special_function */
1326          "R_PPC64_TLSLD",       /* name */
1327          FALSE,                 /* partial_inplace */
1328          0,                     /* src_mask */
1329          0,                     /* dst_mask */
1330          FALSE),                /* pcrel_offset */
1331
1332   HOWTO (R_PPC64_TOCSAVE,
1333          0,                     /* rightshift */
1334          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1335          32,                    /* bitsize */
1336          FALSE,                 /* pc_relative */
1337          0,                     /* bitpos */
1338          complain_overflow_dont, /* complain_on_overflow */
1339          bfd_elf_generic_reloc, /* special_function */
1340          "R_PPC64_TOCSAVE",     /* name */
1341          FALSE,                 /* partial_inplace */
1342          0,                     /* src_mask */
1343          0,                     /* dst_mask */
1344          FALSE),                /* pcrel_offset */
1345
1346   /* Computes the load module index of the load module that contains the
1347      definition of its TLS sym.  */
1348   HOWTO (R_PPC64_DTPMOD64,
1349          0,                     /* rightshift */
1350          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1351          64,                    /* bitsize */
1352          FALSE,                 /* pc_relative */
1353          0,                     /* bitpos */
1354          complain_overflow_dont, /* complain_on_overflow */
1355          ppc64_elf_unhandled_reloc, /* special_function */
1356          "R_PPC64_DTPMOD64",    /* name */
1357          FALSE,                 /* partial_inplace */
1358          0,                     /* src_mask */
1359          ONES (64),             /* dst_mask */
1360          FALSE),                /* pcrel_offset */
1361
1362   /* Computes a dtv-relative displacement, the difference between the value
1363      of sym+add and the base address of the thread-local storage block that
1364      contains the definition of sym, minus 0x8000.  */
1365   HOWTO (R_PPC64_DTPREL64,
1366          0,                     /* rightshift */
1367          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1368          64,                    /* bitsize */
1369          FALSE,                 /* pc_relative */
1370          0,                     /* bitpos */
1371          complain_overflow_dont, /* complain_on_overflow */
1372          ppc64_elf_unhandled_reloc, /* special_function */
1373          "R_PPC64_DTPREL64",    /* name */
1374          FALSE,                 /* partial_inplace */
1375          0,                     /* src_mask */
1376          ONES (64),             /* dst_mask */
1377          FALSE),                /* pcrel_offset */
1378
1379   /* A 16 bit dtprel reloc.  */
1380   HOWTO (R_PPC64_DTPREL16,
1381          0,                     /* rightshift */
1382          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1383          16,                    /* bitsize */
1384          FALSE,                 /* pc_relative */
1385          0,                     /* bitpos */
1386          complain_overflow_signed, /* complain_on_overflow */
1387          ppc64_elf_unhandled_reloc, /* special_function */
1388          "R_PPC64_DTPREL16",    /* name */
1389          FALSE,                 /* partial_inplace */
1390          0,                     /* src_mask */
1391          0xffff,                /* dst_mask */
1392          FALSE),                /* pcrel_offset */
1393
1394   /* Like DTPREL16, but no overflow.  */
1395   HOWTO (R_PPC64_DTPREL16_LO,
1396          0,                     /* rightshift */
1397          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1398          16,                    /* bitsize */
1399          FALSE,                 /* pc_relative */
1400          0,                     /* bitpos */
1401          complain_overflow_dont, /* complain_on_overflow */
1402          ppc64_elf_unhandled_reloc, /* special_function */
1403          "R_PPC64_DTPREL16_LO", /* name */
1404          FALSE,                 /* partial_inplace */
1405          0,                     /* src_mask */
1406          0xffff,                /* dst_mask */
1407          FALSE),                /* pcrel_offset */
1408
1409   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1410   HOWTO (R_PPC64_DTPREL16_HI,
1411          16,                    /* rightshift */
1412          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1413          16,                    /* bitsize */
1414          FALSE,                 /* pc_relative */
1415          0,                     /* bitpos */
1416          complain_overflow_signed, /* complain_on_overflow */
1417          ppc64_elf_unhandled_reloc, /* special_function */
1418          "R_PPC64_DTPREL16_HI", /* name */
1419          FALSE,                 /* partial_inplace */
1420          0,                     /* src_mask */
1421          0xffff,                /* dst_mask */
1422          FALSE),                /* pcrel_offset */
1423
1424   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1425   HOWTO (R_PPC64_DTPREL16_HA,
1426          16,                    /* rightshift */
1427          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1428          16,                    /* bitsize */
1429          FALSE,                 /* pc_relative */
1430          0,                     /* bitpos */
1431          complain_overflow_signed, /* complain_on_overflow */
1432          ppc64_elf_unhandled_reloc, /* special_function */
1433          "R_PPC64_DTPREL16_HA", /* name */
1434          FALSE,                 /* partial_inplace */
1435          0,                     /* src_mask */
1436          0xffff,                /* dst_mask */
1437          FALSE),                /* pcrel_offset */
1438
1439   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1440   HOWTO (R_PPC64_DTPREL16_HIGHER,
1441          32,                    /* rightshift */
1442          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1443          16,                    /* bitsize */
1444          FALSE,                 /* pc_relative */
1445          0,                     /* bitpos */
1446          complain_overflow_dont, /* complain_on_overflow */
1447          ppc64_elf_unhandled_reloc, /* special_function */
1448          "R_PPC64_DTPREL16_HIGHER", /* name */
1449          FALSE,                 /* partial_inplace */
1450          0,                     /* src_mask */
1451          0xffff,                /* dst_mask */
1452          FALSE),                /* pcrel_offset */
1453
1454   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1455   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1456          32,                    /* rightshift */
1457          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1458          16,                    /* bitsize */
1459          FALSE,                 /* pc_relative */
1460          0,                     /* bitpos */
1461          complain_overflow_dont, /* complain_on_overflow */
1462          ppc64_elf_unhandled_reloc, /* special_function */
1463          "R_PPC64_DTPREL16_HIGHERA", /* name */
1464          FALSE,                 /* partial_inplace */
1465          0,                     /* src_mask */
1466          0xffff,                /* dst_mask */
1467          FALSE),                /* pcrel_offset */
1468
1469   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1470   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1471          48,                    /* rightshift */
1472          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1473          16,                    /* bitsize */
1474          FALSE,                 /* pc_relative */
1475          0,                     /* bitpos */
1476          complain_overflow_dont, /* complain_on_overflow */
1477          ppc64_elf_unhandled_reloc, /* special_function */
1478          "R_PPC64_DTPREL16_HIGHEST", /* name */
1479          FALSE,                 /* partial_inplace */
1480          0,                     /* src_mask */
1481          0xffff,                /* dst_mask */
1482          FALSE),                /* pcrel_offset */
1483
1484   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1485   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1486          48,                    /* rightshift */
1487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1488          16,                    /* bitsize */
1489          FALSE,                 /* pc_relative */
1490          0,                     /* bitpos */
1491          complain_overflow_dont, /* complain_on_overflow */
1492          ppc64_elf_unhandled_reloc, /* special_function */
1493          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1494          FALSE,                 /* partial_inplace */
1495          0,                     /* src_mask */
1496          0xffff,                /* dst_mask */
1497          FALSE),                /* pcrel_offset */
1498
1499   /* Like DTPREL16, but for insns with a DS field.  */
1500   HOWTO (R_PPC64_DTPREL16_DS,
1501          0,                     /* rightshift */
1502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1503          16,                    /* bitsize */
1504          FALSE,                 /* pc_relative */
1505          0,                     /* bitpos */
1506          complain_overflow_signed, /* complain_on_overflow */
1507          ppc64_elf_unhandled_reloc, /* special_function */
1508          "R_PPC64_DTPREL16_DS", /* name */
1509          FALSE,                 /* partial_inplace */
1510          0,                     /* src_mask */
1511          0xfffc,                /* dst_mask */
1512          FALSE),                /* pcrel_offset */
1513
1514   /* Like DTPREL16_DS, but no overflow.  */
1515   HOWTO (R_PPC64_DTPREL16_LO_DS,
1516          0,                     /* rightshift */
1517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1518          16,                    /* bitsize */
1519          FALSE,                 /* pc_relative */
1520          0,                     /* bitpos */
1521          complain_overflow_dont, /* complain_on_overflow */
1522          ppc64_elf_unhandled_reloc, /* special_function */
1523          "R_PPC64_DTPREL16_LO_DS", /* name */
1524          FALSE,                 /* partial_inplace */
1525          0,                     /* src_mask */
1526          0xfffc,                /* dst_mask */
1527          FALSE),                /* pcrel_offset */
1528
1529   /* Computes a tp-relative displacement, the difference between the value of
1530      sym+add and the value of the thread pointer (r13).  */
1531   HOWTO (R_PPC64_TPREL64,
1532          0,                     /* rightshift */
1533          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1534          64,                    /* bitsize */
1535          FALSE,                 /* pc_relative */
1536          0,                     /* bitpos */
1537          complain_overflow_dont, /* complain_on_overflow */
1538          ppc64_elf_unhandled_reloc, /* special_function */
1539          "R_PPC64_TPREL64",     /* name */
1540          FALSE,                 /* partial_inplace */
1541          0,                     /* src_mask */
1542          ONES (64),             /* dst_mask */
1543          FALSE),                /* pcrel_offset */
1544
1545   /* A 16 bit tprel reloc.  */
1546   HOWTO (R_PPC64_TPREL16,
1547          0,                     /* rightshift */
1548          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1549          16,                    /* bitsize */
1550          FALSE,                 /* pc_relative */
1551          0,                     /* bitpos */
1552          complain_overflow_signed, /* complain_on_overflow */
1553          ppc64_elf_unhandled_reloc, /* special_function */
1554          "R_PPC64_TPREL16",     /* name */
1555          FALSE,                 /* partial_inplace */
1556          0,                     /* src_mask */
1557          0xffff,                /* dst_mask */
1558          FALSE),                /* pcrel_offset */
1559
1560   /* Like TPREL16, but no overflow.  */
1561   HOWTO (R_PPC64_TPREL16_LO,
1562          0,                     /* rightshift */
1563          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1564          16,                    /* bitsize */
1565          FALSE,                 /* pc_relative */
1566          0,                     /* bitpos */
1567          complain_overflow_dont, /* complain_on_overflow */
1568          ppc64_elf_unhandled_reloc, /* special_function */
1569          "R_PPC64_TPREL16_LO",  /* name */
1570          FALSE,                 /* partial_inplace */
1571          0,                     /* src_mask */
1572          0xffff,                /* dst_mask */
1573          FALSE),                /* pcrel_offset */
1574
1575   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1576   HOWTO (R_PPC64_TPREL16_HI,
1577          16,                    /* rightshift */
1578          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1579          16,                    /* bitsize */
1580          FALSE,                 /* pc_relative */
1581          0,                     /* bitpos */
1582          complain_overflow_signed, /* complain_on_overflow */
1583          ppc64_elf_unhandled_reloc, /* special_function */
1584          "R_PPC64_TPREL16_HI",  /* name */
1585          FALSE,                 /* partial_inplace */
1586          0,                     /* src_mask */
1587          0xffff,                /* dst_mask */
1588          FALSE),                /* pcrel_offset */
1589
1590   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1591   HOWTO (R_PPC64_TPREL16_HA,
1592          16,                    /* rightshift */
1593          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1594          16,                    /* bitsize */
1595          FALSE,                 /* pc_relative */
1596          0,                     /* bitpos */
1597          complain_overflow_signed, /* complain_on_overflow */
1598          ppc64_elf_unhandled_reloc, /* special_function */
1599          "R_PPC64_TPREL16_HA",  /* name */
1600          FALSE,                 /* partial_inplace */
1601          0,                     /* src_mask */
1602          0xffff,                /* dst_mask */
1603          FALSE),                /* pcrel_offset */
1604
1605   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1606   HOWTO (R_PPC64_TPREL16_HIGHER,
1607          32,                    /* rightshift */
1608          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1609          16,                    /* bitsize */
1610          FALSE,                 /* pc_relative */
1611          0,                     /* bitpos */
1612          complain_overflow_dont, /* complain_on_overflow */
1613          ppc64_elf_unhandled_reloc, /* special_function */
1614          "R_PPC64_TPREL16_HIGHER",      /* name */
1615          FALSE,                 /* partial_inplace */
1616          0,                     /* src_mask */
1617          0xffff,                /* dst_mask */
1618          FALSE),                /* pcrel_offset */
1619
1620   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1621   HOWTO (R_PPC64_TPREL16_HIGHERA,
1622          32,                    /* rightshift */
1623          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1624          16,                    /* bitsize */
1625          FALSE,                 /* pc_relative */
1626          0,                     /* bitpos */
1627          complain_overflow_dont, /* complain_on_overflow */
1628          ppc64_elf_unhandled_reloc, /* special_function */
1629          "R_PPC64_TPREL16_HIGHERA", /* name */
1630          FALSE,                 /* partial_inplace */
1631          0,                     /* src_mask */
1632          0xffff,                /* dst_mask */
1633          FALSE),                /* pcrel_offset */
1634
1635   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1636   HOWTO (R_PPC64_TPREL16_HIGHEST,
1637          48,                    /* rightshift */
1638          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1639          16,                    /* bitsize */
1640          FALSE,                 /* pc_relative */
1641          0,                     /* bitpos */
1642          complain_overflow_dont, /* complain_on_overflow */
1643          ppc64_elf_unhandled_reloc, /* special_function */
1644          "R_PPC64_TPREL16_HIGHEST", /* name */
1645          FALSE,                 /* partial_inplace */
1646          0,                     /* src_mask */
1647          0xffff,                /* dst_mask */
1648          FALSE),                /* pcrel_offset */
1649
1650   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1651   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1652          48,                    /* rightshift */
1653          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1654          16,                    /* bitsize */
1655          FALSE,                 /* pc_relative */
1656          0,                     /* bitpos */
1657          complain_overflow_dont, /* complain_on_overflow */
1658          ppc64_elf_unhandled_reloc, /* special_function */
1659          "R_PPC64_TPREL16_HIGHESTA", /* name */
1660          FALSE,                 /* partial_inplace */
1661          0,                     /* src_mask */
1662          0xffff,                /* dst_mask */
1663          FALSE),                /* pcrel_offset */
1664
1665   /* Like TPREL16, but for insns with a DS field.  */
1666   HOWTO (R_PPC64_TPREL16_DS,
1667          0,                     /* rightshift */
1668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1669          16,                    /* bitsize */
1670          FALSE,                 /* pc_relative */
1671          0,                     /* bitpos */
1672          complain_overflow_signed, /* complain_on_overflow */
1673          ppc64_elf_unhandled_reloc, /* special_function */
1674          "R_PPC64_TPREL16_DS",  /* name */
1675          FALSE,                 /* partial_inplace */
1676          0,                     /* src_mask */
1677          0xfffc,                /* dst_mask */
1678          FALSE),                /* pcrel_offset */
1679
1680   /* Like TPREL16_DS, but no overflow.  */
1681   HOWTO (R_PPC64_TPREL16_LO_DS,
1682          0,                     /* rightshift */
1683          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1684          16,                    /* bitsize */
1685          FALSE,                 /* pc_relative */
1686          0,                     /* bitpos */
1687          complain_overflow_dont, /* complain_on_overflow */
1688          ppc64_elf_unhandled_reloc, /* special_function */
1689          "R_PPC64_TPREL16_LO_DS", /* name */
1690          FALSE,                 /* partial_inplace */
1691          0,                     /* src_mask */
1692          0xfffc,                /* dst_mask */
1693          FALSE),                /* pcrel_offset */
1694
1695   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1696      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1697      to the first entry relative to the TOC base (r2).  */
1698   HOWTO (R_PPC64_GOT_TLSGD16,
1699          0,                     /* rightshift */
1700          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1701          16,                    /* bitsize */
1702          FALSE,                 /* pc_relative */
1703          0,                     /* bitpos */
1704          complain_overflow_signed, /* complain_on_overflow */
1705          ppc64_elf_unhandled_reloc, /* special_function */
1706          "R_PPC64_GOT_TLSGD16", /* name */
1707          FALSE,                 /* partial_inplace */
1708          0,                     /* src_mask */
1709          0xffff,                /* dst_mask */
1710          FALSE),                /* pcrel_offset */
1711
1712   /* Like GOT_TLSGD16, but no overflow.  */
1713   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1714          0,                     /* rightshift */
1715          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1716          16,                    /* bitsize */
1717          FALSE,                 /* pc_relative */
1718          0,                     /* bitpos */
1719          complain_overflow_dont, /* complain_on_overflow */
1720          ppc64_elf_unhandled_reloc, /* special_function */
1721          "R_PPC64_GOT_TLSGD16_LO", /* name */
1722          FALSE,                 /* partial_inplace */
1723          0,                     /* src_mask */
1724          0xffff,                /* dst_mask */
1725          FALSE),                /* pcrel_offset */
1726
1727   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1728   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1729          16,                    /* rightshift */
1730          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1731          16,                    /* bitsize */
1732          FALSE,                 /* pc_relative */
1733          0,                     /* bitpos */
1734          complain_overflow_signed, /* complain_on_overflow */
1735          ppc64_elf_unhandled_reloc, /* special_function */
1736          "R_PPC64_GOT_TLSGD16_HI", /* name */
1737          FALSE,                 /* partial_inplace */
1738          0,                     /* src_mask */
1739          0xffff,                /* dst_mask */
1740          FALSE),                /* pcrel_offset */
1741
1742   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1743   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1744          16,                    /* rightshift */
1745          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1746          16,                    /* bitsize */
1747          FALSE,                 /* pc_relative */
1748          0,                     /* bitpos */
1749          complain_overflow_signed, /* complain_on_overflow */
1750          ppc64_elf_unhandled_reloc, /* special_function */
1751          "R_PPC64_GOT_TLSGD16_HA", /* name */
1752          FALSE,                 /* partial_inplace */
1753          0,                     /* src_mask */
1754          0xffff,                /* dst_mask */
1755          FALSE),                /* pcrel_offset */
1756
1757   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1758      with values (sym+add)@dtpmod and zero, and computes the offset to the
1759      first entry relative to the TOC base (r2).  */
1760   HOWTO (R_PPC64_GOT_TLSLD16,
1761          0,                     /* rightshift */
1762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1763          16,                    /* bitsize */
1764          FALSE,                 /* pc_relative */
1765          0,                     /* bitpos */
1766          complain_overflow_signed, /* complain_on_overflow */
1767          ppc64_elf_unhandled_reloc, /* special_function */
1768          "R_PPC64_GOT_TLSLD16", /* name */
1769          FALSE,                 /* partial_inplace */
1770          0,                     /* src_mask */
1771          0xffff,                /* dst_mask */
1772          FALSE),                /* pcrel_offset */
1773
1774   /* Like GOT_TLSLD16, but no overflow.  */
1775   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1776          0,                     /* rightshift */
1777          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1778          16,                    /* bitsize */
1779          FALSE,                 /* pc_relative */
1780          0,                     /* bitpos */
1781          complain_overflow_dont, /* complain_on_overflow */
1782          ppc64_elf_unhandled_reloc, /* special_function */
1783          "R_PPC64_GOT_TLSLD16_LO", /* name */
1784          FALSE,                 /* partial_inplace */
1785          0,                     /* src_mask */
1786          0xffff,                /* dst_mask */
1787          FALSE),                /* pcrel_offset */
1788
1789   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1790   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1791          16,                    /* rightshift */
1792          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1793          16,                    /* bitsize */
1794          FALSE,                 /* pc_relative */
1795          0,                     /* bitpos */
1796          complain_overflow_signed, /* complain_on_overflow */
1797          ppc64_elf_unhandled_reloc, /* special_function */
1798          "R_PPC64_GOT_TLSLD16_HI", /* name */
1799          FALSE,                 /* partial_inplace */
1800          0,                     /* src_mask */
1801          0xffff,                /* dst_mask */
1802          FALSE),                /* pcrel_offset */
1803
1804   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1805   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1806          16,                    /* rightshift */
1807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1808          16,                    /* bitsize */
1809          FALSE,                 /* pc_relative */
1810          0,                     /* bitpos */
1811          complain_overflow_signed, /* complain_on_overflow */
1812          ppc64_elf_unhandled_reloc, /* special_function */
1813          "R_PPC64_GOT_TLSLD16_HA", /* name */
1814          FALSE,                 /* partial_inplace */
1815          0,                     /* src_mask */
1816          0xffff,                /* dst_mask */
1817          FALSE),                /* pcrel_offset */
1818
1819   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1820      the offset to the entry relative to the TOC base (r2).  */
1821   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1822          0,                     /* rightshift */
1823          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1824          16,                    /* bitsize */
1825          FALSE,                 /* pc_relative */
1826          0,                     /* bitpos */
1827          complain_overflow_signed, /* complain_on_overflow */
1828          ppc64_elf_unhandled_reloc, /* special_function */
1829          "R_PPC64_GOT_DTPREL16_DS", /* name */
1830          FALSE,                 /* partial_inplace */
1831          0,                     /* src_mask */
1832          0xfffc,                /* dst_mask */
1833          FALSE),                /* pcrel_offset */
1834
1835   /* Like GOT_DTPREL16_DS, but no overflow.  */
1836   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1837          0,                     /* rightshift */
1838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1839          16,                    /* bitsize */
1840          FALSE,                 /* pc_relative */
1841          0,                     /* bitpos */
1842          complain_overflow_dont, /* complain_on_overflow */
1843          ppc64_elf_unhandled_reloc, /* special_function */
1844          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1845          FALSE,                 /* partial_inplace */
1846          0,                     /* src_mask */
1847          0xfffc,                /* dst_mask */
1848          FALSE),                /* pcrel_offset */
1849
1850   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1851   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1852          16,                    /* rightshift */
1853          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1854          16,                    /* bitsize */
1855          FALSE,                 /* pc_relative */
1856          0,                     /* bitpos */
1857          complain_overflow_signed, /* complain_on_overflow */
1858          ppc64_elf_unhandled_reloc, /* special_function */
1859          "R_PPC64_GOT_DTPREL16_HI", /* name */
1860          FALSE,                 /* partial_inplace */
1861          0,                     /* src_mask */
1862          0xffff,                /* dst_mask */
1863          FALSE),                /* pcrel_offset */
1864
1865   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1866   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1867          16,                    /* rightshift */
1868          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1869          16,                    /* bitsize */
1870          FALSE,                 /* pc_relative */
1871          0,                     /* bitpos */
1872          complain_overflow_signed, /* complain_on_overflow */
1873          ppc64_elf_unhandled_reloc, /* special_function */
1874          "R_PPC64_GOT_DTPREL16_HA", /* name */
1875          FALSE,                 /* partial_inplace */
1876          0,                     /* src_mask */
1877          0xffff,                /* dst_mask */
1878          FALSE),                /* pcrel_offset */
1879
1880   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1881      offset to the entry relative to the TOC base (r2).  */
1882   HOWTO (R_PPC64_GOT_TPREL16_DS,
1883          0,                     /* rightshift */
1884          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1885          16,                    /* bitsize */
1886          FALSE,                 /* pc_relative */
1887          0,                     /* bitpos */
1888          complain_overflow_signed, /* complain_on_overflow */
1889          ppc64_elf_unhandled_reloc, /* special_function */
1890          "R_PPC64_GOT_TPREL16_DS", /* name */
1891          FALSE,                 /* partial_inplace */
1892          0,                     /* src_mask */
1893          0xfffc,                /* dst_mask */
1894          FALSE),                /* pcrel_offset */
1895
1896   /* Like GOT_TPREL16_DS, but no overflow.  */
1897   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1898          0,                     /* rightshift */
1899          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1900          16,                    /* bitsize */
1901          FALSE,                 /* pc_relative */
1902          0,                     /* bitpos */
1903          complain_overflow_dont, /* complain_on_overflow */
1904          ppc64_elf_unhandled_reloc, /* special_function */
1905          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1906          FALSE,                 /* partial_inplace */
1907          0,                     /* src_mask */
1908          0xfffc,                /* dst_mask */
1909          FALSE),                /* pcrel_offset */
1910
1911   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1912   HOWTO (R_PPC64_GOT_TPREL16_HI,
1913          16,                    /* rightshift */
1914          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1915          16,                    /* bitsize */
1916          FALSE,                 /* pc_relative */
1917          0,                     /* bitpos */
1918          complain_overflow_signed, /* complain_on_overflow */
1919          ppc64_elf_unhandled_reloc, /* special_function */
1920          "R_PPC64_GOT_TPREL16_HI", /* name */
1921          FALSE,                 /* partial_inplace */
1922          0,                     /* src_mask */
1923          0xffff,                /* dst_mask */
1924          FALSE),                /* pcrel_offset */
1925
1926   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1927   HOWTO (R_PPC64_GOT_TPREL16_HA,
1928          16,                    /* rightshift */
1929          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1930          16,                    /* bitsize */
1931          FALSE,                 /* pc_relative */
1932          0,                     /* bitpos */
1933          complain_overflow_signed, /* complain_on_overflow */
1934          ppc64_elf_unhandled_reloc, /* special_function */
1935          "R_PPC64_GOT_TPREL16_HA", /* name */
1936          FALSE,                 /* partial_inplace */
1937          0,                     /* src_mask */
1938          0xffff,                /* dst_mask */
1939          FALSE),                /* pcrel_offset */
1940
1941   HOWTO (R_PPC64_JMP_IREL,      /* type */
1942          0,                     /* rightshift */
1943          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1944          0,                     /* bitsize */
1945          FALSE,                 /* pc_relative */
1946          0,                     /* bitpos */
1947          complain_overflow_dont, /* complain_on_overflow */
1948          ppc64_elf_unhandled_reloc, /* special_function */
1949          "R_PPC64_JMP_IREL",    /* name */
1950          FALSE,                 /* partial_inplace */
1951          0,                     /* src_mask */
1952          0,                     /* dst_mask */
1953          FALSE),                /* pcrel_offset */
1954
1955   HOWTO (R_PPC64_IRELATIVE,     /* type */
1956          0,                     /* rightshift */
1957          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1958          64,                    /* bitsize */
1959          FALSE,                 /* pc_relative */
1960          0,                     /* bitpos */
1961          complain_overflow_dont, /* complain_on_overflow */
1962          bfd_elf_generic_reloc, /* special_function */
1963          "R_PPC64_IRELATIVE",   /* name */
1964          FALSE,                 /* partial_inplace */
1965          0,                     /* src_mask */
1966          ONES (64),             /* dst_mask */
1967          FALSE),                /* pcrel_offset */
1968
1969   /* A 16 bit relative relocation.  */
1970   HOWTO (R_PPC64_REL16,         /* type */
1971          0,                     /* rightshift */
1972          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1973          16,                    /* bitsize */
1974          TRUE,                  /* pc_relative */
1975          0,                     /* bitpos */
1976          complain_overflow_signed, /* complain_on_overflow */
1977          bfd_elf_generic_reloc, /* special_function */
1978          "R_PPC64_REL16",       /* name */
1979          FALSE,                 /* partial_inplace */
1980          0,                     /* src_mask */
1981          0xffff,                /* dst_mask */
1982          TRUE),                 /* pcrel_offset */
1983
1984   /* A 16 bit relative relocation without overflow.  */
1985   HOWTO (R_PPC64_REL16_LO,      /* type */
1986          0,                     /* rightshift */
1987          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1988          16,                    /* bitsize */
1989          TRUE,                  /* pc_relative */
1990          0,                     /* bitpos */
1991          complain_overflow_dont,/* complain_on_overflow */
1992          bfd_elf_generic_reloc, /* special_function */
1993          "R_PPC64_REL16_LO",    /* name */
1994          FALSE,                 /* partial_inplace */
1995          0,                     /* src_mask */
1996          0xffff,                /* dst_mask */
1997          TRUE),                 /* pcrel_offset */
1998
1999   /* The high order 16 bits of a relative address.  */
2000   HOWTO (R_PPC64_REL16_HI,      /* type */
2001          16,                    /* rightshift */
2002          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2003          16,                    /* bitsize */
2004          TRUE,                  /* pc_relative */
2005          0,                     /* bitpos */
2006          complain_overflow_signed, /* complain_on_overflow */
2007          bfd_elf_generic_reloc, /* special_function */
2008          "R_PPC64_REL16_HI",    /* name */
2009          FALSE,                 /* partial_inplace */
2010          0,                     /* src_mask */
2011          0xffff,                /* dst_mask */
2012          TRUE),                 /* pcrel_offset */
2013
2014   /* The high order 16 bits of a relative address, plus 1 if the contents of
2015      the low 16 bits, treated as a signed number, is negative.  */
2016   HOWTO (R_PPC64_REL16_HA,      /* type */
2017          16,                    /* rightshift */
2018          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2019          16,                    /* bitsize */
2020          TRUE,                  /* pc_relative */
2021          0,                     /* bitpos */
2022          complain_overflow_signed, /* complain_on_overflow */
2023          ppc64_elf_ha_reloc,    /* special_function */
2024          "R_PPC64_REL16_HA",    /* name */
2025          FALSE,                 /* partial_inplace */
2026          0,                     /* src_mask */
2027          0xffff,                /* dst_mask */
2028          TRUE),                 /* pcrel_offset */
2029
2030   /* Like R_PPC64_REL16_HA but for split field in addpcis.  */
2031   HOWTO (R_PPC64_REL16DX_HA,    /* type */
2032          16,                    /* rightshift */
2033          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2034          16,                    /* bitsize */
2035          TRUE,                  /* pc_relative */
2036          0,                     /* bitpos */
2037          complain_overflow_signed, /* complain_on_overflow */
2038          ppc64_elf_ha_reloc,    /* special_function */
2039          "R_PPC64_REL16DX_HA",  /* name */
2040          FALSE,                 /* partial_inplace */
2041          0,                     /* src_mask */
2042          0x1fffc1,              /* dst_mask */
2043          TRUE),                 /* pcrel_offset */
2044
2045   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2046   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2047          16,                    /* rightshift */
2048          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2049          16,                    /* bitsize */
2050          FALSE,                 /* pc_relative */
2051          0,                     /* bitpos */
2052          complain_overflow_dont, /* complain_on_overflow */
2053          bfd_elf_generic_reloc, /* special_function */
2054          "R_PPC64_ADDR16_HIGH", /* name */
2055          FALSE,                 /* partial_inplace */
2056          0,                     /* src_mask */
2057          0xffff,                /* dst_mask */
2058          FALSE),                /* pcrel_offset */
2059
2060   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2061   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2062          16,                    /* rightshift */
2063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2064          16,                    /* bitsize */
2065          FALSE,                 /* pc_relative */
2066          0,                     /* bitpos */
2067          complain_overflow_dont, /* complain_on_overflow */
2068          ppc64_elf_ha_reloc,    /* special_function */
2069          "R_PPC64_ADDR16_HIGHA",        /* name */
2070          FALSE,                 /* partial_inplace */
2071          0,                     /* src_mask */
2072          0xffff,                /* dst_mask */
2073          FALSE),                /* pcrel_offset */
2074
2075   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2076   HOWTO (R_PPC64_DTPREL16_HIGH,
2077          16,                    /* rightshift */
2078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2079          16,                    /* bitsize */
2080          FALSE,                 /* pc_relative */
2081          0,                     /* bitpos */
2082          complain_overflow_dont, /* complain_on_overflow */
2083          ppc64_elf_unhandled_reloc, /* special_function */
2084          "R_PPC64_DTPREL16_HIGH", /* name */
2085          FALSE,                 /* partial_inplace */
2086          0,                     /* src_mask */
2087          0xffff,                /* dst_mask */
2088          FALSE),                /* pcrel_offset */
2089
2090   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2091   HOWTO (R_PPC64_DTPREL16_HIGHA,
2092          16,                    /* rightshift */
2093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2094          16,                    /* bitsize */
2095          FALSE,                 /* pc_relative */
2096          0,                     /* bitpos */
2097          complain_overflow_dont, /* complain_on_overflow */
2098          ppc64_elf_unhandled_reloc, /* special_function */
2099          "R_PPC64_DTPREL16_HIGHA", /* name */
2100          FALSE,                 /* partial_inplace */
2101          0,                     /* src_mask */
2102          0xffff,                /* dst_mask */
2103          FALSE),                /* pcrel_offset */
2104
2105   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2106   HOWTO (R_PPC64_TPREL16_HIGH,
2107          16,                    /* rightshift */
2108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2109          16,                    /* bitsize */
2110          FALSE,                 /* pc_relative */
2111          0,                     /* bitpos */
2112          complain_overflow_dont, /* complain_on_overflow */
2113          ppc64_elf_unhandled_reloc, /* special_function */
2114          "R_PPC64_TPREL16_HIGH",        /* name */
2115          FALSE,                 /* partial_inplace */
2116          0,                     /* src_mask */
2117          0xffff,                /* dst_mask */
2118          FALSE),                /* pcrel_offset */
2119
2120   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2121   HOWTO (R_PPC64_TPREL16_HIGHA,
2122          16,                    /* rightshift */
2123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2124          16,                    /* bitsize */
2125          FALSE,                 /* pc_relative */
2126          0,                     /* bitpos */
2127          complain_overflow_dont, /* complain_on_overflow */
2128          ppc64_elf_unhandled_reloc, /* special_function */
2129          "R_PPC64_TPREL16_HIGHA",       /* name */
2130          FALSE,                 /* partial_inplace */
2131          0,                     /* src_mask */
2132          0xffff,                /* dst_mask */
2133          FALSE),                /* pcrel_offset */
2134
2135   /* Marker reloc on ELFv2 large-model function entry.  */
2136   HOWTO (R_PPC64_ENTRY,
2137          0,                     /* rightshift */
2138          2,                     /* size (0 = byte, 1 = short, 2 = long) */
2139          32,                    /* bitsize */
2140          FALSE,                 /* pc_relative */
2141          0,                     /* bitpos */
2142          complain_overflow_dont, /* complain_on_overflow */
2143          bfd_elf_generic_reloc, /* special_function */
2144          "R_PPC64_ENTRY",       /* name */
2145          FALSE,                 /* partial_inplace */
2146          0,                     /* src_mask */
2147          0,                     /* dst_mask */
2148          FALSE),                /* pcrel_offset */
2149
2150   /* Like ADDR64, but use local entry point of function.  */
2151   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2152          0,                     /* rightshift */
2153          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2154          64,                    /* bitsize */
2155          FALSE,                 /* pc_relative */
2156          0,                     /* bitpos */
2157          complain_overflow_dont, /* complain_on_overflow */
2158          bfd_elf_generic_reloc, /* special_function */
2159          "R_PPC64_ADDR64_LOCAL", /* name */
2160          FALSE,                 /* partial_inplace */
2161          0,                     /* src_mask */
2162          ONES (64),             /* dst_mask */
2163          FALSE),                /* pcrel_offset */
2164
2165   /* GNU extension to record C++ vtable hierarchy.  */
2166   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2167          0,                     /* rightshift */
2168          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2169          0,                     /* bitsize */
2170          FALSE,                 /* pc_relative */
2171          0,                     /* bitpos */
2172          complain_overflow_dont, /* complain_on_overflow */
2173          NULL,                  /* special_function */
2174          "R_PPC64_GNU_VTINHERIT", /* name */
2175          FALSE,                 /* partial_inplace */
2176          0,                     /* src_mask */
2177          0,                     /* dst_mask */
2178          FALSE),                /* pcrel_offset */
2179
2180   /* GNU extension to record C++ vtable member usage.  */
2181   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2182          0,                     /* rightshift */
2183          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2184          0,                     /* bitsize */
2185          FALSE,                 /* pc_relative */
2186          0,                     /* bitpos */
2187          complain_overflow_dont, /* complain_on_overflow */
2188          NULL,                  /* special_function */
2189          "R_PPC64_GNU_VTENTRY", /* name */
2190          FALSE,                 /* partial_inplace */
2191          0,                     /* src_mask */
2192          0,                     /* dst_mask */
2193          FALSE),                /* pcrel_offset */
2194 };
2195
2196 \f
2197 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2198    be done.  */
2199
2200 static void
2201 ppc_howto_init (void)
2202 {
2203   unsigned int i, type;
2204
2205   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2206     {
2207       type = ppc64_elf_howto_raw[i].type;
2208       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2209       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2210     }
2211 }
2212
2213 static reloc_howto_type *
2214 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2215                              bfd_reloc_code_real_type code)
2216 {
2217   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2218
2219   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2220     /* Initialize howto table if needed.  */
2221     ppc_howto_init ();
2222
2223   switch (code)
2224     {
2225     default:
2226       return NULL;
2227
2228     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2229       break;
2230     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2231       break;
2232     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2233       break;
2234     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2235       break;
2236     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2237       break;
2238     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2239       break;
2240     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2241       break;
2242     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2243       break;
2244     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2245       break;
2246     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2247       break;
2248     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2249       break;
2250     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2251       break;
2252     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2253       break;
2254     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2255       break;
2256     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2257       break;
2258     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2259       break;
2260     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2261       break;
2262     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2263       break;
2264     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2265       break;
2266     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2267       break;
2268     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2269       break;
2270     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2271       break;
2272     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2273       break;
2274     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2275       break;
2276     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2277       break;
2278     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2279       break;
2280     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2281       break;
2282     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2283       break;
2284     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2285       break;
2286     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2287       break;
2288     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2289       break;
2290     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2291       break;
2292     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2293       break;
2294     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2295       break;
2296     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2297       break;
2298     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2299       break;
2300     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2301       break;
2302     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2303       break;
2304     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2305       break;
2306     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2307       break;
2308     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2309       break;
2310     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2311       break;
2312     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2313       break;
2314     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2315       break;
2316     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2319       break;
2320     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2321       break;
2322     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2323       break;
2324     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2325       break;
2326     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2327       break;
2328     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2329       break;
2330     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2331       break;
2332     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2333       break;
2334     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2335       break;
2336     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2337       break;
2338     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2339       break;
2340     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2343       break;
2344     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2345       break;
2346     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2347       break;
2348     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2351       break;
2352     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2353       break;
2354     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2355       break;
2356     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2357       break;
2358     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2359       break;
2360     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2361       break;
2362     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2363       break;
2364     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2365       break;
2366     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2367       break;
2368     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2369       break;
2370     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2371       break;
2372     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2373       break;
2374     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2375       break;
2376     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2377       break;
2378     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2379       break;
2380     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2381       break;
2382     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2383       break;
2384     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2385       break;
2386     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2387       break;
2388     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2389       break;
2390     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2391       break;
2392     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2393       break;
2394     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2395       break;
2396     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2397       break;
2398     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2399       break;
2400     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2401       break;
2402     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2403       break;
2404     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2405       break;
2406     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2407       break;
2408     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2409       break;
2410     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2411       break;
2412     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2413       break;
2414     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2415       break;
2416     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2417       break;
2418     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2419       break;
2420     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2421       break;
2422     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2423       break;
2424     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2425       break;
2426     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2427       break;
2428     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2429       break;
2430     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2431       break;
2432     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2433       break;
2434     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2435       break;
2436     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2437       break;
2438     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2439       break;
2440     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2441       break;
2442     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2443       break;
2444     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2445       break;
2446     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2447       break;
2448     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2449       break;
2450     case BFD_RELOC_PPC_REL16DX_HA:              r = R_PPC64_REL16DX_HA;
2451       break;
2452     case BFD_RELOC_PPC64_ENTRY:                 r = R_PPC64_ENTRY;
2453       break;
2454     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2455       break;
2456     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2457       break;
2458     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2459       break;
2460     }
2461
2462   return ppc64_elf_howto_table[r];
2463 };
2464
2465 static reloc_howto_type *
2466 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2467                              const char *r_name)
2468 {
2469   unsigned int i;
2470
2471   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2472     if (ppc64_elf_howto_raw[i].name != NULL
2473         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2474       return &ppc64_elf_howto_raw[i];
2475
2476   return NULL;
2477 }
2478
2479 /* Set the howto pointer for a PowerPC ELF reloc.  */
2480
2481 static void
2482 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2483                          Elf_Internal_Rela *dst)
2484 {
2485   unsigned int type;
2486
2487   /* Initialize howto table if needed.  */
2488   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2489     ppc_howto_init ();
2490
2491   type = ELF64_R_TYPE (dst->r_info);
2492   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2493     {
2494       /* xgettext:c-format */
2495       _bfd_error_handler (_("%B: invalid relocation type %d"),
2496                           abfd, (int) type);
2497       type = R_PPC64_NONE;
2498     }
2499   cache_ptr->howto = ppc64_elf_howto_table[type];
2500 }
2501
2502 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2503
2504 static bfd_reloc_status_type
2505 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2506                     void *data, asection *input_section,
2507                     bfd *output_bfd, char **error_message)
2508 {
2509   enum elf_ppc64_reloc_type r_type;
2510   long insn;
2511   bfd_size_type octets;
2512   bfd_vma value;
2513
2514   /* If this is a relocatable link (output_bfd test tells us), just
2515      call the generic function.  Any adjustment will be done at final
2516      link time.  */
2517   if (output_bfd != NULL)
2518     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2519                                   input_section, output_bfd, error_message);
2520
2521   /* Adjust the addend for sign extension of the low 16 bits.
2522      We won't actually be using the low 16 bits, so trashing them
2523      doesn't matter.  */
2524   reloc_entry->addend += 0x8000;
2525   r_type = reloc_entry->howto->type;
2526   if (r_type != R_PPC64_REL16DX_HA)
2527     return bfd_reloc_continue;
2528
2529   value = 0;
2530   if (!bfd_is_com_section (symbol->section))
2531     value = symbol->value;
2532   value += (reloc_entry->addend
2533             + symbol->section->output_offset
2534             + symbol->section->output_section->vma);
2535   value -= (reloc_entry->address
2536             + input_section->output_offset
2537             + input_section->output_section->vma);
2538   value = (bfd_signed_vma) value >> 16;
2539
2540   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2541   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2542   insn &= ~0x1fffc1;
2543   insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2544   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2545   if (value + 0x8000 > 0xffff)
2546     return bfd_reloc_overflow;
2547   return bfd_reloc_ok;
2548 }
2549
2550 static bfd_reloc_status_type
2551 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2552                         void *data, asection *input_section,
2553                         bfd *output_bfd, char **error_message)
2554 {
2555   if (output_bfd != NULL)
2556     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2557                                   input_section, output_bfd, error_message);
2558
2559   if (strcmp (symbol->section->name, ".opd") == 0
2560       && (symbol->section->owner->flags & DYNAMIC) == 0)
2561     {
2562       bfd_vma dest = opd_entry_value (symbol->section,
2563                                       symbol->value + reloc_entry->addend,
2564                                       NULL, NULL, FALSE);
2565       if (dest != (bfd_vma) -1)
2566         reloc_entry->addend = dest - (symbol->value
2567                                       + symbol->section->output_section->vma
2568                                       + symbol->section->output_offset);
2569     }
2570   else
2571     {
2572       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2573
2574       if (symbol->section->owner != abfd
2575           && symbol->section->owner != NULL
2576           && abiversion (symbol->section->owner) >= 2)
2577         {
2578           unsigned int i;
2579
2580           for (i = 0; i < symbol->section->owner->symcount; ++i)
2581             {
2582               asymbol *symdef = symbol->section->owner->outsymbols[i];
2583
2584               if (strcmp (symdef->name, symbol->name) == 0)
2585                 {
2586                   elfsym = (elf_symbol_type *) symdef;
2587                   break;
2588                 }
2589             }
2590         }
2591       reloc_entry->addend
2592         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2593     }
2594   return bfd_reloc_continue;
2595 }
2596
2597 static bfd_reloc_status_type
2598 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2599                          void *data, asection *input_section,
2600                          bfd *output_bfd, char **error_message)
2601 {
2602   long insn;
2603   enum elf_ppc64_reloc_type r_type;
2604   bfd_size_type octets;
2605   /* Assume 'at' branch hints.  */
2606   bfd_boolean is_isa_v2 = TRUE;
2607
2608   /* If this is a relocatable link (output_bfd test tells us), just
2609      call the generic function.  Any adjustment will be done at final
2610      link time.  */
2611   if (output_bfd != NULL)
2612     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613                                   input_section, output_bfd, error_message);
2614
2615   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2616   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2617   insn &= ~(0x01 << 21);
2618   r_type = reloc_entry->howto->type;
2619   if (r_type == R_PPC64_ADDR14_BRTAKEN
2620       || r_type == R_PPC64_REL14_BRTAKEN)
2621     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2622
2623   if (is_isa_v2)
2624     {
2625       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2626          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2627          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2628       if ((insn & (0x14 << 21)) == (0x04 << 21))
2629         insn |= 0x02 << 21;
2630       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2631         insn |= 0x08 << 21;
2632       else
2633         goto out;
2634     }
2635   else
2636     {
2637       bfd_vma target = 0;
2638       bfd_vma from;
2639
2640       if (!bfd_is_com_section (symbol->section))
2641         target = symbol->value;
2642       target += symbol->section->output_section->vma;
2643       target += symbol->section->output_offset;
2644       target += reloc_entry->addend;
2645
2646       from = (reloc_entry->address
2647               + input_section->output_offset
2648               + input_section->output_section->vma);
2649
2650       /* Invert 'y' bit if not the default.  */
2651       if ((bfd_signed_vma) (target - from) < 0)
2652         insn ^= 0x01 << 21;
2653     }
2654   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2655  out:
2656   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2657                                  input_section, output_bfd, error_message);
2658 }
2659
2660 static bfd_reloc_status_type
2661 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2662                          void *data, asection *input_section,
2663                          bfd *output_bfd, char **error_message)
2664 {
2665   /* If this is a relocatable link (output_bfd test tells us), just
2666      call the generic function.  Any adjustment will be done at final
2667      link time.  */
2668   if (output_bfd != NULL)
2669     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2670                                   input_section, output_bfd, error_message);
2671
2672   /* Subtract the symbol section base address.  */
2673   reloc_entry->addend -= symbol->section->output_section->vma;
2674   return bfd_reloc_continue;
2675 }
2676
2677 static bfd_reloc_status_type
2678 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2679                             void *data, asection *input_section,
2680                             bfd *output_bfd, char **error_message)
2681 {
2682   /* If this is a relocatable link (output_bfd test tells us), just
2683      call the generic function.  Any adjustment will be done at final
2684      link time.  */
2685   if (output_bfd != NULL)
2686     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2687                                   input_section, output_bfd, error_message);
2688
2689   /* Subtract the symbol section base address.  */
2690   reloc_entry->addend -= symbol->section->output_section->vma;
2691
2692   /* Adjust the addend for sign extension of the low 16 bits.  */
2693   reloc_entry->addend += 0x8000;
2694   return bfd_reloc_continue;
2695 }
2696
2697 static bfd_reloc_status_type
2698 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699                      void *data, asection *input_section,
2700                      bfd *output_bfd, char **error_message)
2701 {
2702   bfd_vma TOCstart;
2703
2704   /* If this is a relocatable link (output_bfd test tells us), just
2705      call the generic function.  Any adjustment will be done at final
2706      link time.  */
2707   if (output_bfd != NULL)
2708     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2709                                   input_section, output_bfd, error_message);
2710
2711   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2712   if (TOCstart == 0)
2713     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2714
2715   /* Subtract the TOC base address.  */
2716   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2717   return bfd_reloc_continue;
2718 }
2719
2720 static bfd_reloc_status_type
2721 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2722                         void *data, asection *input_section,
2723                         bfd *output_bfd, char **error_message)
2724 {
2725   bfd_vma TOCstart;
2726
2727   /* If this is a relocatable link (output_bfd test tells us), just
2728      call the generic function.  Any adjustment will be done at final
2729      link time.  */
2730   if (output_bfd != NULL)
2731     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2732                                   input_section, output_bfd, error_message);
2733
2734   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2735   if (TOCstart == 0)
2736     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2737
2738   /* Subtract the TOC base address.  */
2739   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2740
2741   /* Adjust the addend for sign extension of the low 16 bits.  */
2742   reloc_entry->addend += 0x8000;
2743   return bfd_reloc_continue;
2744 }
2745
2746 static bfd_reloc_status_type
2747 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2748                        void *data, asection *input_section,
2749                        bfd *output_bfd, char **error_message)
2750 {
2751   bfd_vma TOCstart;
2752   bfd_size_type octets;
2753
2754   /* If this is a relocatable link (output_bfd test tells us), just
2755      call the generic function.  Any adjustment will be done at final
2756      link time.  */
2757   if (output_bfd != NULL)
2758     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2759                                   input_section, output_bfd, error_message);
2760
2761   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2762   if (TOCstart == 0)
2763     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2764
2765   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2766   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2767   return bfd_reloc_ok;
2768 }
2769
2770 static bfd_reloc_status_type
2771 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2772                            void *data, asection *input_section,
2773                            bfd *output_bfd, char **error_message)
2774 {
2775   /* If this is a relocatable link (output_bfd test tells us), just
2776      call the generic function.  Any adjustment will be done at final
2777      link time.  */
2778   if (output_bfd != NULL)
2779     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780                                   input_section, output_bfd, error_message);
2781
2782   if (error_message != NULL)
2783     {
2784       static char buf[60];
2785       sprintf (buf, "generic linker can't handle %s",
2786                reloc_entry->howto->name);
2787       *error_message = buf;
2788     }
2789   return bfd_reloc_dangerous;
2790 }
2791
2792 /* Track GOT entries needed for a given symbol.  We might need more
2793    than one got entry per symbol.  */
2794 struct got_entry
2795 {
2796   struct got_entry *next;
2797
2798   /* The symbol addend that we'll be placing in the GOT.  */
2799   bfd_vma addend;
2800
2801   /* Unlike other ELF targets, we use separate GOT entries for the same
2802      symbol referenced from different input files.  This is to support
2803      automatic multiple TOC/GOT sections, where the TOC base can vary
2804      from one input file to another.  After partitioning into TOC groups
2805      we merge entries within the group.
2806
2807      Point to the BFD owning this GOT entry.  */
2808   bfd *owner;
2809
2810   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2811      TLS_TPREL or TLS_DTPREL for tls entries.  */
2812   unsigned char tls_type;
2813
2814   /* Non-zero if got.ent points to real entry.  */
2815   unsigned char is_indirect;
2816
2817   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2818   union
2819     {
2820       bfd_signed_vma refcount;
2821       bfd_vma offset;
2822       struct got_entry *ent;
2823     } got;
2824 };
2825
2826 /* The same for PLT.  */
2827 struct plt_entry
2828 {
2829   struct plt_entry *next;
2830
2831   bfd_vma addend;
2832
2833   union
2834     {
2835       bfd_signed_vma refcount;
2836       bfd_vma offset;
2837     } plt;
2838 };
2839
2840 struct ppc64_elf_obj_tdata
2841 {
2842   struct elf_obj_tdata elf;
2843
2844   /* Shortcuts to dynamic linker sections.  */
2845   asection *got;
2846   asection *relgot;
2847
2848   /* Used during garbage collection.  We attach global symbols defined
2849      on removed .opd entries to this section so that the sym is removed.  */
2850   asection *deleted_section;
2851
2852   /* TLS local dynamic got entry handling.  Support for multiple GOT
2853      sections means we potentially need one of these for each input bfd.  */
2854   struct got_entry tlsld_got;
2855
2856   union {
2857     /* A copy of relocs before they are modified for --emit-relocs.  */
2858     Elf_Internal_Rela *relocs;
2859
2860     /* Section contents.  */
2861     bfd_byte *contents;
2862   } opd;
2863
2864   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2865      the reloc to be in the range -32768 to 32767.  */
2866   unsigned int has_small_toc_reloc : 1;
2867
2868   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2869      instruction not one we handle.  */
2870   unsigned int unexpected_toc_insn : 1;
2871 };
2872
2873 #define ppc64_elf_tdata(bfd) \
2874   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2875
2876 #define ppc64_tlsld_got(bfd) \
2877   (&ppc64_elf_tdata (bfd)->tlsld_got)
2878
2879 #define is_ppc64_elf(bfd) \
2880   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2881    && elf_object_id (bfd) == PPC64_ELF_DATA)
2882
2883 /* Override the generic function because we store some extras.  */
2884
2885 static bfd_boolean
2886 ppc64_elf_mkobject (bfd *abfd)
2887 {
2888   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2889                                   PPC64_ELF_DATA);
2890 }
2891
2892 /* Fix bad default arch selected for a 64 bit input bfd when the
2893    default is 32 bit.  Also select arch based on apuinfo.  */
2894
2895 static bfd_boolean
2896 ppc64_elf_object_p (bfd *abfd)
2897 {
2898   if (!abfd->arch_info->the_default)
2899     return TRUE;
2900
2901   if (abfd->arch_info->bits_per_word == 32)
2902     {
2903       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2904
2905       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2906         {
2907           /* Relies on arch after 32 bit default being 64 bit default.  */
2908           abfd->arch_info = abfd->arch_info->next;
2909           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2910         }
2911     }
2912   return _bfd_elf_ppc_set_arch (abfd);
2913 }
2914
2915 /* Support for core dump NOTE sections.  */
2916
2917 static bfd_boolean
2918 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2919 {
2920   size_t offset, size;
2921
2922   if (note->descsz != 504)
2923     return FALSE;
2924
2925   /* pr_cursig */
2926   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2927
2928   /* pr_pid */
2929   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2930
2931   /* pr_reg */
2932   offset = 112;
2933   size = 384;
2934
2935   /* Make a ".reg/999" section.  */
2936   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2937                                           size, note->descpos + offset);
2938 }
2939
2940 static bfd_boolean
2941 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2942 {
2943   if (note->descsz != 136)
2944     return FALSE;
2945
2946   elf_tdata (abfd)->core->pid
2947     = bfd_get_32 (abfd, note->descdata + 24);
2948   elf_tdata (abfd)->core->program
2949     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2950   elf_tdata (abfd)->core->command
2951     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2952
2953   return TRUE;
2954 }
2955
2956 static char *
2957 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2958                            ...)
2959 {
2960   switch (note_type)
2961     {
2962     default:
2963       return NULL;
2964
2965     case NT_PRPSINFO:
2966       {
2967         char data[136];
2968         va_list ap;
2969
2970         va_start (ap, note_type);
2971         memset (data, 0, sizeof (data));
2972         strncpy (data + 40, va_arg (ap, const char *), 16);
2973         strncpy (data + 56, va_arg (ap, const char *), 80);
2974         va_end (ap);
2975         return elfcore_write_note (abfd, buf, bufsiz,
2976                                    "CORE", note_type, data, sizeof (data));
2977       }
2978
2979     case NT_PRSTATUS:
2980       {
2981         char data[504];
2982         va_list ap;
2983         long pid;
2984         int cursig;
2985         const void *greg;
2986
2987         va_start (ap, note_type);
2988         memset (data, 0, 112);
2989         pid = va_arg (ap, long);
2990         bfd_put_32 (abfd, pid, data + 32);
2991         cursig = va_arg (ap, int);
2992         bfd_put_16 (abfd, cursig, data + 12);
2993         greg = va_arg (ap, const void *);
2994         memcpy (data + 112, greg, 384);
2995         memset (data + 496, 0, 8);
2996         va_end (ap);
2997         return elfcore_write_note (abfd, buf, bufsiz,
2998                                    "CORE", note_type, data, sizeof (data));
2999       }
3000     }
3001 }
3002
3003 /* Add extra PPC sections.  */
3004
3005 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3006 {
3007   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
3008   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3009   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3011   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3012   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3013   { NULL,                     0,  0, 0,            0 }
3014 };
3015
3016 enum _ppc64_sec_type {
3017   sec_normal = 0,
3018   sec_opd = 1,
3019   sec_toc = 2
3020 };
3021
3022 struct _ppc64_elf_section_data
3023 {
3024   struct bfd_elf_section_data elf;
3025
3026   union
3027   {
3028     /* An array with one entry for each opd function descriptor,
3029        and some spares since opd entries may be either 16 or 24 bytes.  */
3030 #define OPD_NDX(OFF) ((OFF) >> 4)
3031     struct _opd_sec_data
3032     {
3033       /* Points to the function code section for local opd entries.  */
3034       asection **func_sec;
3035
3036       /* After editing .opd, adjust references to opd local syms.  */
3037       long *adjust;
3038     } opd;
3039
3040     /* An array for toc sections, indexed by offset/8.  */
3041     struct _toc_sec_data
3042     {
3043       /* Specifies the relocation symbol index used at a given toc offset.  */
3044       unsigned *symndx;
3045
3046       /* And the relocation addend.  */
3047       bfd_vma *add;
3048     } toc;
3049   } u;
3050
3051   enum _ppc64_sec_type sec_type:2;
3052
3053   /* Flag set when small branches are detected.  Used to
3054      select suitable defaults for the stub group size.  */
3055   unsigned int has_14bit_branch:1;
3056 };
3057
3058 #define ppc64_elf_section_data(sec) \
3059   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3060
3061 static bfd_boolean
3062 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3063 {
3064   if (!sec->used_by_bfd)
3065     {
3066       struct _ppc64_elf_section_data *sdata;
3067       bfd_size_type amt = sizeof (*sdata);
3068
3069       sdata = bfd_zalloc (abfd, amt);
3070       if (sdata == NULL)
3071         return FALSE;
3072       sec->used_by_bfd = sdata;
3073     }
3074
3075   return _bfd_elf_new_section_hook (abfd, sec);
3076 }
3077
3078 static struct _opd_sec_data *
3079 get_opd_info (asection * sec)
3080 {
3081   if (sec != NULL
3082       && ppc64_elf_section_data (sec) != NULL
3083       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3084     return &ppc64_elf_section_data (sec)->u.opd;
3085   return NULL;
3086 }
3087 \f
3088 /* Parameters for the qsort hook.  */
3089 static bfd_boolean synthetic_relocatable;
3090 static asection *synthetic_opd;
3091
3092 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3093
3094 static int
3095 compare_symbols (const void *ap, const void *bp)
3096 {
3097   const asymbol *a = * (const asymbol **) ap;
3098   const asymbol *b = * (const asymbol **) bp;
3099
3100   /* Section symbols first.  */
3101   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3102     return -1;
3103   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3104     return 1;
3105
3106   /* then .opd symbols.  */
3107   if (synthetic_opd != NULL)
3108     {
3109       if (strcmp (a->section->name, ".opd") == 0
3110           && strcmp (b->section->name, ".opd") != 0)
3111         return -1;
3112       if (strcmp (a->section->name, ".opd") != 0
3113           && strcmp (b->section->name, ".opd") == 0)
3114         return 1;
3115     }
3116
3117   /* then other code symbols.  */
3118   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119       == (SEC_CODE | SEC_ALLOC)
3120       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3121          != (SEC_CODE | SEC_ALLOC))
3122     return -1;
3123
3124   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125       != (SEC_CODE | SEC_ALLOC)
3126       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3127          == (SEC_CODE | SEC_ALLOC))
3128     return 1;
3129
3130   if (synthetic_relocatable)
3131     {
3132       if (a->section->id < b->section->id)
3133         return -1;
3134
3135       if (a->section->id > b->section->id)
3136         return 1;
3137     }
3138
3139   if (a->value + a->section->vma < b->value + b->section->vma)
3140     return -1;
3141
3142   if (a->value + a->section->vma > b->value + b->section->vma)
3143     return 1;
3144
3145   /* For syms with the same value, prefer strong dynamic global function
3146      syms over other syms.  */
3147   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3148     return -1;
3149
3150   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3151     return 1;
3152
3153   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3154     return -1;
3155
3156   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3157     return 1;
3158
3159   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3160     return -1;
3161
3162   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3163     return 1;
3164
3165   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3166     return -1;
3167
3168   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3169     return 1;
3170
3171   return 0;
3172 }
3173
3174 /* Search SYMS for a symbol of the given VALUE.  */
3175
3176 static asymbol *
3177 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3178 {
3179   long mid;
3180
3181   if (id == (unsigned) -1)
3182     {
3183       while (lo < hi)
3184         {
3185           mid = (lo + hi) >> 1;
3186           if (syms[mid]->value + syms[mid]->section->vma < value)
3187             lo = mid + 1;
3188           else if (syms[mid]->value + syms[mid]->section->vma > value)
3189             hi = mid;
3190           else
3191             return syms[mid];
3192         }
3193     }
3194   else
3195     {
3196       while (lo < hi)
3197         {
3198           mid = (lo + hi) >> 1;
3199           if (syms[mid]->section->id < id)
3200             lo = mid + 1;
3201           else if (syms[mid]->section->id > id)
3202             hi = mid;
3203           else if (syms[mid]->value < value)
3204             lo = mid + 1;
3205           else if (syms[mid]->value > value)
3206             hi = mid;
3207           else
3208             return syms[mid];
3209         }
3210     }
3211   return NULL;
3212 }
3213
3214 static bfd_boolean
3215 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3216 {
3217   bfd_vma vma = *(bfd_vma *) ptr;
3218   return ((section->flags & SEC_ALLOC) != 0
3219           && section->vma <= vma
3220           && vma < section->vma + section->size);
3221 }
3222
3223 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3224    entry syms.  Also generate @plt symbols for the glink branch table.
3225    Returns count of synthetic symbols in RET or -1 on error.  */
3226
3227 static long
3228 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3229                                 long static_count, asymbol **static_syms,
3230                                 long dyn_count, asymbol **dyn_syms,
3231                                 asymbol **ret)
3232 {
3233   asymbol *s;
3234   long i;
3235   long count;
3236   char *names;
3237   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3238   asection *opd = NULL;
3239   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3240   asymbol **syms;
3241   int abi = abiversion (abfd);
3242
3243   *ret = NULL;
3244
3245   if (abi < 2)
3246     {
3247       opd = bfd_get_section_by_name (abfd, ".opd");
3248       if (opd == NULL && abi == 1)
3249         return 0;
3250     }
3251
3252   symcount = static_count;
3253   if (!relocatable)
3254     symcount += dyn_count;
3255   if (symcount == 0)
3256     return 0;
3257
3258   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3259   if (syms == NULL)
3260     return -1;
3261
3262   if (!relocatable && static_count != 0 && dyn_count != 0)
3263     {
3264       /* Use both symbol tables.  */
3265       memcpy (syms, static_syms, static_count * sizeof (*syms));
3266       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3267     }
3268   else if (!relocatable && static_count == 0)
3269     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3270   else
3271     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3272
3273   synthetic_relocatable = relocatable;
3274   synthetic_opd = opd;
3275   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3276
3277   if (!relocatable && symcount > 1)
3278     {
3279       long j;
3280       /* Trim duplicate syms, since we may have merged the normal and
3281          dynamic symbols.  Actually, we only care about syms that have
3282          different values, so trim any with the same value.  */
3283       for (i = 1, j = 1; i < symcount; ++i)
3284         if (syms[i - 1]->value + syms[i - 1]->section->vma
3285             != syms[i]->value + syms[i]->section->vma)
3286           syms[j++] = syms[i];
3287       symcount = j;
3288     }
3289
3290   i = 0;
3291   /* Note that here and in compare_symbols we can't compare opd and
3292      sym->section directly.  With separate debug info files, the
3293      symbols will be extracted from the debug file while abfd passed
3294      to this function is the real binary.  */
3295   if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3296     ++i;
3297   codesecsym = i;
3298
3299   for (; i < symcount; ++i)
3300     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3301          != (SEC_CODE | SEC_ALLOC))
3302         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3303       break;
3304   codesecsymend = i;
3305
3306   for (; i < symcount; ++i)
3307     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3308       break;
3309   secsymend = i;
3310
3311   if (opd != NULL)
3312     for (; i < symcount; ++i)
3313       if (strcmp (syms[i]->section->name, ".opd") != 0)
3314         break;
3315   opdsymend = i;
3316
3317   for (; i < symcount; ++i)
3318     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3319         != (SEC_CODE | SEC_ALLOC))
3320       break;
3321   symcount = i;
3322
3323   count = 0;
3324
3325   if (relocatable)
3326     {
3327       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3328       arelent *r;
3329       size_t size;
3330       long relcount;
3331
3332       if (opdsymend == secsymend)
3333         goto done;
3334
3335       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3336       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3337       if (relcount == 0)
3338         goto done;
3339
3340       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3341         {
3342           count = -1;
3343           goto done;
3344         }
3345
3346       size = 0;
3347       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3348         {
3349           asymbol *sym;
3350
3351           while (r < opd->relocation + relcount
3352                  && r->address < syms[i]->value + opd->vma)
3353             ++r;
3354
3355           if (r == opd->relocation + relcount)
3356             break;
3357
3358           if (r->address != syms[i]->value + opd->vma)
3359             continue;
3360
3361           if (r->howto->type != R_PPC64_ADDR64)
3362             continue;
3363
3364           sym = *r->sym_ptr_ptr;
3365           if (!sym_exists_at (syms, opdsymend, symcount,
3366                               sym->section->id, sym->value + r->addend))
3367             {
3368               ++count;
3369               size += sizeof (asymbol);
3370               size += strlen (syms[i]->name) + 2;
3371             }
3372         }
3373
3374       if (size == 0)
3375         goto done;
3376       s = *ret = bfd_malloc (size);
3377       if (s == NULL)
3378         {
3379           count = -1;
3380           goto done;
3381         }
3382
3383       names = (char *) (s + count);
3384
3385       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3386         {
3387           asymbol *sym;
3388
3389           while (r < opd->relocation + relcount
3390                  && r->address < syms[i]->value + opd->vma)
3391             ++r;
3392
3393           if (r == opd->relocation + relcount)
3394             break;
3395
3396           if (r->address != syms[i]->value + opd->vma)
3397             continue;
3398
3399           if (r->howto->type != R_PPC64_ADDR64)
3400             continue;
3401
3402           sym = *r->sym_ptr_ptr;
3403           if (!sym_exists_at (syms, opdsymend, symcount,
3404                               sym->section->id, sym->value + r->addend))
3405             {
3406               size_t len;
3407
3408               *s = *syms[i];
3409               s->flags |= BSF_SYNTHETIC;
3410               s->section = sym->section;
3411               s->value = sym->value + r->addend;
3412               s->name = names;
3413               *names++ = '.';
3414               len = strlen (syms[i]->name);
3415               memcpy (names, syms[i]->name, len + 1);
3416               names += len + 1;
3417               /* Have udata.p point back to the original symbol this
3418                  synthetic symbol was derived from.  */
3419               s->udata.p = syms[i];
3420               s++;
3421             }
3422         }
3423     }
3424   else
3425     {
3426       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3427       bfd_byte *contents = NULL;
3428       size_t size;
3429       long plt_count = 0;
3430       bfd_vma glink_vma = 0, resolv_vma = 0;
3431       asection *dynamic, *glink = NULL, *relplt = NULL;
3432       arelent *p;
3433
3434       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3435         {
3436         free_contents_and_exit_err:
3437           count = -1;
3438         free_contents_and_exit:
3439           if (contents)
3440             free (contents);
3441           goto done;
3442         }
3443
3444       size = 0;
3445       for (i = secsymend; i < opdsymend; ++i)
3446         {
3447           bfd_vma ent;
3448
3449           /* Ignore bogus symbols.  */
3450           if (syms[i]->value > opd->size - 8)
3451             continue;
3452
3453           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3454           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3455             {
3456               ++count;
3457               size += sizeof (asymbol);
3458               size += strlen (syms[i]->name) + 2;
3459             }
3460         }
3461
3462       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3463       if (dyn_count != 0
3464           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3465         {
3466           bfd_byte *dynbuf, *extdyn, *extdynend;
3467           size_t extdynsize;
3468           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3469
3470           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3471             goto free_contents_and_exit_err;
3472
3473           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3474           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3475
3476           extdyn = dynbuf;
3477           extdynend = extdyn + dynamic->size;
3478           for (; extdyn < extdynend; extdyn += extdynsize)
3479             {
3480               Elf_Internal_Dyn dyn;
3481               (*swap_dyn_in) (abfd, extdyn, &dyn);
3482
3483               if (dyn.d_tag == DT_NULL)
3484                 break;
3485
3486               if (dyn.d_tag == DT_PPC64_GLINK)
3487                 {
3488                   /* The first glink stub starts at offset 32; see
3489                      comment in ppc64_elf_finish_dynamic_sections. */
3490                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3491                   /* The .glink section usually does not survive the final
3492                      link; search for the section (usually .text) where the
3493                      glink stubs now reside.  */
3494                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3495                                                 &glink_vma);
3496                   break;
3497                 }
3498             }
3499
3500           free (dynbuf);
3501         }
3502
3503       if (glink != NULL)
3504         {
3505           /* Determine __glink trampoline by reading the relative branch
3506              from the first glink stub.  */
3507           bfd_byte buf[4];
3508           unsigned int off = 0;
3509
3510           while (bfd_get_section_contents (abfd, glink, buf,
3511                                            glink_vma + off - glink->vma, 4))
3512             {
3513               unsigned int insn = bfd_get_32 (abfd, buf);
3514               insn ^= B_DOT;
3515               if ((insn & ~0x3fffffc) == 0)
3516                 {
3517                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3518                   break;
3519                 }
3520               off += 4;
3521               if (off > 4)
3522                 break;
3523             }
3524
3525           if (resolv_vma)
3526             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3527
3528           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3529           if (relplt != NULL)
3530             {
3531               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3532               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3533                 goto free_contents_and_exit_err;
3534
3535               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3536               size += plt_count * sizeof (asymbol);
3537
3538               p = relplt->relocation;
3539               for (i = 0; i < plt_count; i++, p++)
3540                 {
3541                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3542                   if (p->addend != 0)
3543                     size += sizeof ("+0x") - 1 + 16;
3544                 }
3545             }
3546         }
3547
3548       if (size == 0)
3549         goto free_contents_and_exit;
3550       s = *ret = bfd_malloc (size);
3551       if (s == NULL)
3552         goto free_contents_and_exit_err;
3553
3554       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3555
3556       for (i = secsymend; i < opdsymend; ++i)
3557         {
3558           bfd_vma ent;
3559
3560           if (syms[i]->value > opd->size - 8)
3561             continue;
3562
3563           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3564           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3565             {
3566               long lo, hi;
3567               size_t len;
3568               asection *sec = abfd->sections;
3569
3570               *s = *syms[i];
3571               lo = codesecsym;
3572               hi = codesecsymend;
3573               while (lo < hi)
3574                 {
3575                   long mid = (lo + hi) >> 1;
3576                   if (syms[mid]->section->vma < ent)
3577                     lo = mid + 1;
3578                   else if (syms[mid]->section->vma > ent)
3579                     hi = mid;
3580                   else
3581                     {
3582                       sec = syms[mid]->section;
3583                       break;
3584                     }
3585                 }
3586
3587               if (lo >= hi && lo > codesecsym)
3588                 sec = syms[lo - 1]->section;
3589
3590               for (; sec != NULL; sec = sec->next)
3591                 {
3592                   if (sec->vma > ent)
3593                     break;
3594                   /* SEC_LOAD may not be set if SEC is from a separate debug
3595                      info file.  */
3596                   if ((sec->flags & SEC_ALLOC) == 0)
3597                     break;
3598                   if ((sec->flags & SEC_CODE) != 0)
3599                     s->section = sec;
3600                 }
3601               s->flags |= BSF_SYNTHETIC;
3602               s->value = ent - s->section->vma;
3603               s->name = names;
3604               *names++ = '.';
3605               len = strlen (syms[i]->name);
3606               memcpy (names, syms[i]->name, len + 1);
3607               names += len + 1;
3608               /* Have udata.p point back to the original symbol this
3609                  synthetic symbol was derived from.  */
3610               s->udata.p = syms[i];
3611               s++;
3612             }
3613         }
3614       free (contents);
3615
3616       if (glink != NULL && relplt != NULL)
3617         {
3618           if (resolv_vma)
3619             {
3620               /* Add a symbol for the main glink trampoline.  */
3621               memset (s, 0, sizeof *s);
3622               s->the_bfd = abfd;
3623               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3624               s->section = glink;
3625               s->value = resolv_vma - glink->vma;
3626               s->name = names;
3627               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3628               names += sizeof ("__glink_PLTresolve");
3629               s++;
3630               count++;
3631             }
3632
3633           /* FIXME: It would be very much nicer to put sym@plt on the
3634              stub rather than on the glink branch table entry.  The
3635              objdump disassembler would then use a sensible symbol
3636              name on plt calls.  The difficulty in doing so is
3637              a) finding the stubs, and,
3638              b) matching stubs against plt entries, and,
3639              c) there can be multiple stubs for a given plt entry.
3640
3641              Solving (a) could be done by code scanning, but older
3642              ppc64 binaries used different stubs to current code.
3643              (b) is the tricky one since you need to known the toc
3644              pointer for at least one function that uses a pic stub to
3645              be able to calculate the plt address referenced.
3646              (c) means gdb would need to set multiple breakpoints (or
3647              find the glink branch itself) when setting breakpoints
3648              for pending shared library loads.  */
3649           p = relplt->relocation;
3650           for (i = 0; i < plt_count; i++, p++)
3651             {
3652               size_t len;
3653
3654               *s = **p->sym_ptr_ptr;
3655               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3656                  we are defining a symbol, ensure one of them is set.  */
3657               if ((s->flags & BSF_LOCAL) == 0)
3658                 s->flags |= BSF_GLOBAL;
3659               s->flags |= BSF_SYNTHETIC;
3660               s->section = glink;
3661               s->value = glink_vma - glink->vma;
3662               s->name = names;
3663               s->udata.p = NULL;
3664               len = strlen ((*p->sym_ptr_ptr)->name);
3665               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3666               names += len;
3667               if (p->addend != 0)
3668                 {
3669                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3670                   names += sizeof ("+0x") - 1;
3671                   bfd_sprintf_vma (abfd, names, p->addend);
3672                   names += strlen (names);
3673                 }
3674               memcpy (names, "@plt", sizeof ("@plt"));
3675               names += sizeof ("@plt");
3676               s++;
3677               if (abi < 2)
3678                 {
3679                   glink_vma += 8;
3680                   if (i >= 0x8000)
3681                     glink_vma += 4;
3682                 }
3683               else
3684                 glink_vma += 4;
3685             }
3686           count += plt_count;
3687         }
3688     }
3689
3690  done:
3691   free (syms);
3692   return count;
3693 }
3694 \f
3695 /* The following functions are specific to the ELF linker, while
3696    functions above are used generally.  Those named ppc64_elf_* are
3697    called by the main ELF linker code.  They appear in this file more
3698    or less in the order in which they are called.  eg.
3699    ppc64_elf_check_relocs is called early in the link process,
3700    ppc64_elf_finish_dynamic_sections is one of the last functions
3701    called.
3702
3703    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3704    functions have both a function code symbol and a function descriptor
3705    symbol.  A call to foo in a relocatable object file looks like:
3706
3707    .            .text
3708    .    x:
3709    .            bl      .foo
3710    .            nop
3711
3712    The function definition in another object file might be:
3713
3714    .            .section .opd
3715    .    foo:    .quad   .foo
3716    .            .quad   .TOC.@tocbase
3717    .            .quad   0
3718    .
3719    .            .text
3720    .    .foo:   blr
3721
3722    When the linker resolves the call during a static link, the branch
3723    unsurprisingly just goes to .foo and the .opd information is unused.
3724    If the function definition is in a shared library, things are a little
3725    different:  The call goes via a plt call stub, the opd information gets
3726    copied to the plt, and the linker patches the nop.
3727
3728    .    x:
3729    .            bl      .foo_stub
3730    .            ld      2,40(1)
3731    .
3732    .
3733    .    .foo_stub:
3734    .            std     2,40(1)                 # in practice, the call stub
3735    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3736    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3737    .            ld      12,0(11)
3738    .            ld      2,8(11)
3739    .            mtctr   12
3740    .            ld      11,16(11)
3741    .            bctr
3742    .
3743    .            .section .plt
3744    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3745
3746    The "reloc ()" notation is supposed to indicate that the linker emits
3747    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3748    copying.
3749
3750    What are the difficulties here?  Well, firstly, the relocations
3751    examined by the linker in check_relocs are against the function code
3752    sym .foo, while the dynamic relocation in the plt is emitted against
3753    the function descriptor symbol, foo.  Somewhere along the line, we need
3754    to carefully copy dynamic link information from one symbol to the other.
3755    Secondly, the generic part of the elf linker will make .foo a dynamic
3756    symbol as is normal for most other backends.  We need foo dynamic
3757    instead, at least for an application final link.  However, when
3758    creating a shared library containing foo, we need to have both symbols
3759    dynamic so that references to .foo are satisfied during the early
3760    stages of linking.  Otherwise the linker might decide to pull in a
3761    definition from some other object, eg. a static library.
3762
3763    Update: As of August 2004, we support a new convention.  Function
3764    calls may use the function descriptor symbol, ie. "bl foo".  This
3765    behaves exactly as "bl .foo".  */
3766
3767 /* Of those relocs that might be copied as dynamic relocs, this function
3768    selects those that must be copied when linking a shared library,
3769    even when the symbol is local.  */
3770
3771 static int
3772 must_be_dyn_reloc (struct bfd_link_info *info,
3773                    enum elf_ppc64_reloc_type r_type)
3774 {
3775   switch (r_type)
3776     {
3777     default:
3778       return 1;
3779
3780     case R_PPC64_REL32:
3781     case R_PPC64_REL64:
3782     case R_PPC64_REL30:
3783       return 0;
3784
3785     case R_PPC64_TPREL16:
3786     case R_PPC64_TPREL16_LO:
3787     case R_PPC64_TPREL16_HI:
3788     case R_PPC64_TPREL16_HA:
3789     case R_PPC64_TPREL16_DS:
3790     case R_PPC64_TPREL16_LO_DS:
3791     case R_PPC64_TPREL16_HIGH:
3792     case R_PPC64_TPREL16_HIGHA:
3793     case R_PPC64_TPREL16_HIGHER:
3794     case R_PPC64_TPREL16_HIGHERA:
3795     case R_PPC64_TPREL16_HIGHEST:
3796     case R_PPC64_TPREL16_HIGHESTA:
3797     case R_PPC64_TPREL64:
3798       return !bfd_link_executable (info);
3799     }
3800 }
3801
3802 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3803    copying dynamic variables from a shared lib into an app's dynbss
3804    section, and instead use a dynamic relocation to point into the
3805    shared lib.  With code that gcc generates, it's vital that this be
3806    enabled;  In the PowerPC64 ABI, the address of a function is actually
3807    the address of a function descriptor, which resides in the .opd
3808    section.  gcc uses the descriptor directly rather than going via the
3809    GOT as some other ABI's do, which means that initialized function
3810    pointers must reference the descriptor.  Thus, a function pointer
3811    initialized to the address of a function in a shared library will
3812    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3813    redefines the function descriptor symbol to point to the copy.  This
3814    presents a problem as a plt entry for that function is also
3815    initialized from the function descriptor symbol and the copy reloc
3816    may not be initialized first.  */
3817 #define ELIMINATE_COPY_RELOCS 1
3818
3819 /* Section name for stubs is the associated section name plus this
3820    string.  */
3821 #define STUB_SUFFIX ".stub"
3822
3823 /* Linker stubs.
3824    ppc_stub_long_branch:
3825    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3826    destination, but a 24 bit branch in a stub section will reach.
3827    .    b       dest
3828
3829    ppc_stub_plt_branch:
3830    Similar to the above, but a 24 bit branch in the stub section won't
3831    reach its destination.
3832    .    addis   %r11,%r2,xxx@toc@ha
3833    .    ld      %r12,xxx@toc@l(%r11)
3834    .    mtctr   %r12
3835    .    bctr
3836
3837    ppc_stub_plt_call:
3838    Used to call a function in a shared library.  If it so happens that
3839    the plt entry referenced crosses a 64k boundary, then an extra
3840    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3841    .    std     %r2,40(%r1)
3842    .    addis   %r11,%r2,xxx@toc@ha
3843    .    ld      %r12,xxx+0@toc@l(%r11)
3844    .    mtctr   %r12
3845    .    ld      %r2,xxx+8@toc@l(%r11)
3846    .    ld      %r11,xxx+16@toc@l(%r11)
3847    .    bctr
3848
3849    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3850    code to adjust the value and save r2 to support multiple toc sections.
3851    A ppc_stub_long_branch with an r2 offset looks like:
3852    .    std     %r2,40(%r1)
3853    .    addis   %r2,%r2,off@ha
3854    .    addi    %r2,%r2,off@l
3855    .    b       dest
3856
3857    A ppc_stub_plt_branch with an r2 offset looks like:
3858    .    std     %r2,40(%r1)
3859    .    addis   %r11,%r2,xxx@toc@ha
3860    .    ld      %r12,xxx@toc@l(%r11)
3861    .    addis   %r2,%r2,off@ha
3862    .    addi    %r2,%r2,off@l
3863    .    mtctr   %r12
3864    .    bctr
3865
3866    In cases where the "addis" instruction would add zero, the "addis" is
3867    omitted and following instructions modified slightly in some cases.
3868 */
3869
3870 enum ppc_stub_type {
3871   ppc_stub_none,
3872   ppc_stub_long_branch,
3873   ppc_stub_long_branch_r2off,
3874   ppc_stub_plt_branch,
3875   ppc_stub_plt_branch_r2off,
3876   ppc_stub_plt_call,
3877   ppc_stub_plt_call_r2save,
3878   ppc_stub_global_entry,
3879   ppc_stub_save_res
3880 };
3881
3882 /* Information on stub grouping.  */
3883 struct map_stub
3884 {
3885   /* The stub section.  */
3886   asection *stub_sec;
3887   /* This is the section to which stubs in the group will be attached.  */
3888   asection *link_sec;
3889   /* Next group.  */
3890   struct map_stub *next;
3891   /* Whether to emit a copy of register save/restore functions in this
3892      group.  */
3893   int needs_save_res;
3894 };
3895
3896 struct ppc_stub_hash_entry {
3897
3898   /* Base hash table entry structure.  */
3899   struct bfd_hash_entry root;
3900
3901   enum ppc_stub_type stub_type;
3902
3903   /* Group information.  */
3904   struct map_stub *group;
3905
3906   /* Offset within stub_sec of the beginning of this stub.  */
3907   bfd_vma stub_offset;
3908
3909   /* Given the symbol's value and its section we can determine its final
3910      value when building the stubs (so the stub knows where to jump.  */
3911   bfd_vma target_value;
3912   asection *target_section;
3913
3914   /* The symbol table entry, if any, that this was derived from.  */
3915   struct ppc_link_hash_entry *h;
3916   struct plt_entry *plt_ent;
3917
3918   /* Symbol st_other.  */
3919   unsigned char other;
3920 };
3921
3922 struct ppc_branch_hash_entry {
3923
3924   /* Base hash table entry structure.  */
3925   struct bfd_hash_entry root;
3926
3927   /* Offset within branch lookup table.  */
3928   unsigned int offset;
3929
3930   /* Generation marker.  */
3931   unsigned int iter;
3932 };
3933
3934 /* Used to track dynamic relocations for local symbols.  */
3935 struct ppc_dyn_relocs
3936 {
3937   struct ppc_dyn_relocs *next;
3938
3939   /* The input section of the reloc.  */
3940   asection *sec;
3941
3942   /* Total number of relocs copied for the input section.  */
3943   unsigned int count : 31;
3944
3945   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3946   unsigned int ifunc : 1;
3947 };
3948
3949 struct ppc_link_hash_entry
3950 {
3951   struct elf_link_hash_entry elf;
3952
3953   union {
3954     /* A pointer to the most recently used stub hash entry against this
3955        symbol.  */
3956     struct ppc_stub_hash_entry *stub_cache;
3957
3958     /* A pointer to the next symbol starting with a '.'  */
3959     struct ppc_link_hash_entry *next_dot_sym;
3960   } u;
3961
3962   /* Track dynamic relocs copied for this symbol.  */
3963   struct elf_dyn_relocs *dyn_relocs;
3964
3965   /* Chain of aliases referring to a weakdef.  */
3966   struct ppc_link_hash_entry *weakref;
3967
3968   /* Link between function code and descriptor symbols.  */
3969   struct ppc_link_hash_entry *oh;
3970
3971   /* Flag function code and descriptor symbols.  */
3972   unsigned int is_func:1;
3973   unsigned int is_func_descriptor:1;
3974   unsigned int fake:1;
3975
3976   /* Whether global opd/toc sym has been adjusted or not.
3977      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3978      should be set for all globals defined in any opd/toc section.  */
3979   unsigned int adjust_done:1;
3980
3981   /* Set if we twiddled this symbol to weak at some stage.  */
3982   unsigned int was_undefined:1;
3983
3984   /* Set if this is an out-of-line register save/restore function,
3985      with non-standard calling convention.  */
3986   unsigned int save_res:1;
3987
3988   /* Contexts in which symbol is used in the GOT (or TOC).
3989      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3990      corresponding relocs are encountered during check_relocs.
3991      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3992      indicate the corresponding GOT entry type is not needed.
3993      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3994      a TPREL one.  We use a separate flag rather than setting TPREL
3995      just for convenience in distinguishing the two cases.  */
3996 #define TLS_GD           1      /* GD reloc. */
3997 #define TLS_LD           2      /* LD reloc. */
3998 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3999 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
4000 #define TLS_TLS         16      /* Any TLS reloc.  */
4001 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
4002 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
4003 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
4004   unsigned char tls_mask;
4005 };
4006
4007 /* ppc64 ELF linker hash table.  */
4008
4009 struct ppc_link_hash_table
4010 {
4011   struct elf_link_hash_table elf;
4012
4013   /* The stub hash table.  */
4014   struct bfd_hash_table stub_hash_table;
4015
4016   /* Another hash table for plt_branch stubs.  */
4017   struct bfd_hash_table branch_hash_table;
4018
4019   /* Hash table for function prologue tocsave.  */
4020   htab_t tocsave_htab;
4021
4022   /* Various options and other info passed from the linker.  */
4023   struct ppc64_elf_params *params;
4024
4025   /* The size of sec_info below.  */
4026   unsigned int sec_info_arr_size;
4027
4028   /* Per-section array of extra section info.  Done this way rather
4029      than as part of ppc64_elf_section_data so we have the info for
4030      non-ppc64 sections.  */
4031   struct
4032   {
4033     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
4034     bfd_vma toc_off;
4035
4036     union
4037     {
4038       /* The section group that this section belongs to.  */
4039       struct map_stub *group;
4040       /* A temp section list pointer.  */
4041       asection *list;
4042     } u;
4043   } *sec_info;
4044
4045   /* Linked list of groups.  */
4046   struct map_stub *group;
4047
4048   /* Temp used when calculating TOC pointers.  */
4049   bfd_vma toc_curr;
4050   bfd *toc_bfd;
4051   asection *toc_first_sec;
4052
4053   /* Used when adding symbols.  */
4054   struct ppc_link_hash_entry *dot_syms;
4055
4056   /* Shortcuts to get to dynamic linker sections.  */
4057   asection *dynbss;
4058   asection *relbss;
4059   asection *glink;
4060   asection *sfpr;
4061   asection *brlt;
4062   asection *relbrlt;
4063   asection *glink_eh_frame;
4064
4065   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
4066   struct ppc_link_hash_entry *tls_get_addr;
4067   struct ppc_link_hash_entry *tls_get_addr_fd;
4068
4069   /* The size of reliplt used by got entry relocs.  */
4070   bfd_size_type got_reli_size;
4071
4072   /* Statistics.  */
4073   unsigned long stub_count[ppc_stub_global_entry];
4074
4075   /* Number of stubs against global syms.  */
4076   unsigned long stub_globals;
4077
4078   /* Set if we're linking code with function descriptors.  */
4079   unsigned int opd_abi:1;
4080
4081   /* Support for multiple toc sections.  */
4082   unsigned int do_multi_toc:1;
4083   unsigned int multi_toc_needed:1;
4084   unsigned int second_toc_pass:1;
4085   unsigned int do_toc_opt:1;
4086
4087   /* Set on error.  */
4088   unsigned int stub_error:1;
4089
4090   /* Temp used by ppc64_elf_before_check_relocs.  */
4091   unsigned int twiddled_syms:1;
4092
4093   /* Incremented every time we size stubs.  */
4094   unsigned int stub_iteration;
4095
4096   /* Small local sym cache.  */
4097   struct sym_cache sym_cache;
4098 };
4099
4100 /* Rename some of the generic section flags to better document how they
4101    are used here.  */
4102
4103 /* Nonzero if this section has TLS related relocations.  */
4104 #define has_tls_reloc sec_flg0
4105
4106 /* Nonzero if this section has a call to __tls_get_addr.  */
4107 #define has_tls_get_addr_call sec_flg1
4108
4109 /* Nonzero if this section has any toc or got relocs.  */
4110 #define has_toc_reloc sec_flg2
4111
4112 /* Nonzero if this section has a call to another section that uses
4113    the toc or got.  */
4114 #define makes_toc_func_call sec_flg3
4115
4116 /* Recursion protection when determining above flag.  */
4117 #define call_check_in_progress sec_flg4
4118 #define call_check_done sec_flg5
4119
4120 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4121
4122 #define ppc_hash_table(p) \
4123   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4124   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4125
4126 #define ppc_stub_hash_lookup(table, string, create, copy) \
4127   ((struct ppc_stub_hash_entry *) \
4128    bfd_hash_lookup ((table), (string), (create), (copy)))
4129
4130 #define ppc_branch_hash_lookup(table, string, create, copy) \
4131   ((struct ppc_branch_hash_entry *) \
4132    bfd_hash_lookup ((table), (string), (create), (copy)))
4133
4134 /* Create an entry in the stub hash table.  */
4135
4136 static struct bfd_hash_entry *
4137 stub_hash_newfunc (struct bfd_hash_entry *entry,
4138                    struct bfd_hash_table *table,
4139                    const char *string)
4140 {
4141   /* Allocate the structure if it has not already been allocated by a
4142      subclass.  */
4143   if (entry == NULL)
4144     {
4145       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4146       if (entry == NULL)
4147         return entry;
4148     }
4149
4150   /* Call the allocation method of the superclass.  */
4151   entry = bfd_hash_newfunc (entry, table, string);
4152   if (entry != NULL)
4153     {
4154       struct ppc_stub_hash_entry *eh;
4155
4156       /* Initialize the local fields.  */
4157       eh = (struct ppc_stub_hash_entry *) entry;
4158       eh->stub_type = ppc_stub_none;
4159       eh->group = NULL;
4160       eh->stub_offset = 0;
4161       eh->target_value = 0;
4162       eh->target_section = NULL;
4163       eh->h = NULL;
4164       eh->plt_ent = NULL;
4165       eh->other = 0;
4166     }
4167
4168   return entry;
4169 }
4170
4171 /* Create an entry in the branch hash table.  */
4172
4173 static struct bfd_hash_entry *
4174 branch_hash_newfunc (struct bfd_hash_entry *entry,
4175                      struct bfd_hash_table *table,
4176                      const char *string)
4177 {
4178   /* Allocate the structure if it has not already been allocated by a
4179      subclass.  */
4180   if (entry == NULL)
4181     {
4182       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4183       if (entry == NULL)
4184         return entry;
4185     }
4186
4187   /* Call the allocation method of the superclass.  */
4188   entry = bfd_hash_newfunc (entry, table, string);
4189   if (entry != NULL)
4190     {
4191       struct ppc_branch_hash_entry *eh;
4192
4193       /* Initialize the local fields.  */
4194       eh = (struct ppc_branch_hash_entry *) entry;
4195       eh->offset = 0;
4196       eh->iter = 0;
4197     }
4198
4199   return entry;
4200 }
4201
4202 /* Create an entry in a ppc64 ELF linker hash table.  */
4203
4204 static struct bfd_hash_entry *
4205 link_hash_newfunc (struct bfd_hash_entry *entry,
4206                    struct bfd_hash_table *table,
4207                    const char *string)
4208 {
4209   /* Allocate the structure if it has not already been allocated by a
4210      subclass.  */
4211   if (entry == NULL)
4212     {
4213       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4214       if (entry == NULL)
4215         return entry;
4216     }
4217
4218   /* Call the allocation method of the superclass.  */
4219   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4220   if (entry != NULL)
4221     {
4222       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4223
4224       memset (&eh->u.stub_cache, 0,
4225               (sizeof (struct ppc_link_hash_entry)
4226                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4227
4228       /* When making function calls, old ABI code references function entry
4229          points (dot symbols), while new ABI code references the function
4230          descriptor symbol.  We need to make any combination of reference and
4231          definition work together, without breaking archive linking.
4232
4233          For a defined function "foo" and an undefined call to "bar":
4234          An old object defines "foo" and ".foo", references ".bar" (possibly
4235          "bar" too).
4236          A new object defines "foo" and references "bar".
4237
4238          A new object thus has no problem with its undefined symbols being
4239          satisfied by definitions in an old object.  On the other hand, the
4240          old object won't have ".bar" satisfied by a new object.
4241
4242          Keep a list of newly added dot-symbols.  */
4243
4244       if (string[0] == '.')
4245         {
4246           struct ppc_link_hash_table *htab;
4247
4248           htab = (struct ppc_link_hash_table *) table;
4249           eh->u.next_dot_sym = htab->dot_syms;
4250           htab->dot_syms = eh;
4251         }
4252     }
4253
4254   return entry;
4255 }
4256
4257 struct tocsave_entry {
4258   asection *sec;
4259   bfd_vma offset;
4260 };
4261
4262 static hashval_t
4263 tocsave_htab_hash (const void *p)
4264 {
4265   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4266   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4267 }
4268
4269 static int
4270 tocsave_htab_eq (const void *p1, const void *p2)
4271 {
4272   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4273   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4274   return e1->sec == e2->sec && e1->offset == e2->offset;
4275 }
4276
4277 /* Destroy a ppc64 ELF linker hash table.  */
4278
4279 static void
4280 ppc64_elf_link_hash_table_free (bfd *obfd)
4281 {
4282   struct ppc_link_hash_table *htab;
4283
4284   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4285   if (htab->tocsave_htab)
4286     htab_delete (htab->tocsave_htab);
4287   bfd_hash_table_free (&htab->branch_hash_table);
4288   bfd_hash_table_free (&htab->stub_hash_table);
4289   _bfd_elf_link_hash_table_free (obfd);
4290 }
4291
4292 /* Create a ppc64 ELF linker hash table.  */
4293
4294 static struct bfd_link_hash_table *
4295 ppc64_elf_link_hash_table_create (bfd *abfd)
4296 {
4297   struct ppc_link_hash_table *htab;
4298   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4299
4300   htab = bfd_zmalloc (amt);
4301   if (htab == NULL)
4302     return NULL;
4303
4304   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4305                                       sizeof (struct ppc_link_hash_entry),
4306                                       PPC64_ELF_DATA))
4307     {
4308       free (htab);
4309       return NULL;
4310     }
4311
4312   /* Init the stub hash table too.  */
4313   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4314                             sizeof (struct ppc_stub_hash_entry)))
4315     {
4316       _bfd_elf_link_hash_table_free (abfd);
4317       return NULL;
4318     }
4319
4320   /* And the branch hash table.  */
4321   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4322                             sizeof (struct ppc_branch_hash_entry)))
4323     {
4324       bfd_hash_table_free (&htab->stub_hash_table);
4325       _bfd_elf_link_hash_table_free (abfd);
4326       return NULL;
4327     }
4328
4329   htab->tocsave_htab = htab_try_create (1024,
4330                                         tocsave_htab_hash,
4331                                         tocsave_htab_eq,
4332                                         NULL);
4333   if (htab->tocsave_htab == NULL)
4334     {
4335       ppc64_elf_link_hash_table_free (abfd);
4336       return NULL;
4337     }
4338   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4339
4340   /* Initializing two fields of the union is just cosmetic.  We really
4341      only care about glist, but when compiled on a 32-bit host the
4342      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4343      debugger inspection of these fields look nicer.  */
4344   htab->elf.init_got_refcount.refcount = 0;
4345   htab->elf.init_got_refcount.glist = NULL;
4346   htab->elf.init_plt_refcount.refcount = 0;
4347   htab->elf.init_plt_refcount.glist = NULL;
4348   htab->elf.init_got_offset.offset = 0;
4349   htab->elf.init_got_offset.glist = NULL;
4350   htab->elf.init_plt_offset.offset = 0;
4351   htab->elf.init_plt_offset.glist = NULL;
4352
4353   return &htab->elf.root;
4354 }
4355
4356 /* Create sections for linker generated code.  */
4357
4358 static bfd_boolean
4359 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4360 {
4361   struct ppc_link_hash_table *htab;
4362   flagword flags;
4363
4364   htab = ppc_hash_table (info);
4365
4366   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4367            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4368   if (htab->params->save_restore_funcs)
4369     {
4370       /* Create .sfpr for code to save and restore fp regs.  */
4371       htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4372                                                        flags);
4373       if (htab->sfpr == NULL
4374           || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4375         return FALSE;
4376     }
4377
4378   if (bfd_link_relocatable (info))
4379     return TRUE;
4380
4381   /* Create .glink for lazy dynamic linking support.  */
4382   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4383                                                     flags);
4384   if (htab->glink == NULL
4385       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4386     return FALSE;
4387
4388   if (!info->no_ld_generated_unwind_info)
4389     {
4390       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4391                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4392       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4393                                                                  ".eh_frame",
4394                                                                  flags);
4395       if (htab->glink_eh_frame == NULL
4396           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4397         return FALSE;
4398     }
4399
4400   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4401   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4402   if (htab->elf.iplt == NULL
4403       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4404     return FALSE;
4405
4406   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4407            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4408   htab->elf.irelplt
4409     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4410   if (htab->elf.irelplt == NULL
4411       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4412     return FALSE;
4413
4414   /* Create branch lookup table for plt_branch stubs.  */
4415   flags = (SEC_ALLOC | SEC_LOAD
4416            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4417   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4418                                                    flags);
4419   if (htab->brlt == NULL
4420       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4421     return FALSE;
4422
4423   if (!bfd_link_pic (info))
4424     return TRUE;
4425
4426   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4427            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4428   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4429                                                       ".rela.branch_lt",
4430                                                       flags);
4431   if (htab->relbrlt == NULL
4432       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4433     return FALSE;
4434
4435   return TRUE;
4436 }
4437
4438 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4439
4440 bfd_boolean
4441 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4442                          struct ppc64_elf_params *params)
4443 {
4444   struct ppc_link_hash_table *htab;
4445
4446   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4447
4448 /* Always hook our dynamic sections into the first bfd, which is the
4449    linker created stub bfd.  This ensures that the GOT header is at
4450    the start of the output TOC section.  */
4451   htab = ppc_hash_table (info);
4452   htab->elf.dynobj = params->stub_bfd;
4453   htab->params = params;
4454
4455   return create_linkage_sections (htab->elf.dynobj, info);
4456 }
4457
4458 /* Build a name for an entry in the stub hash table.  */
4459
4460 static char *
4461 ppc_stub_name (const asection *input_section,
4462                const asection *sym_sec,
4463                const struct ppc_link_hash_entry *h,
4464                const Elf_Internal_Rela *rel)
4465 {
4466   char *stub_name;
4467   ssize_t len;
4468
4469   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4470      offsets from a sym as a branch target?  In fact, we could
4471      probably assume the addend is always zero.  */
4472   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4473
4474   if (h)
4475     {
4476       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4477       stub_name = bfd_malloc (len);
4478       if (stub_name == NULL)
4479         return stub_name;
4480
4481       len = sprintf (stub_name, "%08x.%s+%x",
4482                      input_section->id & 0xffffffff,
4483                      h->elf.root.root.string,
4484                      (int) rel->r_addend & 0xffffffff);
4485     }
4486   else
4487     {
4488       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4489       stub_name = bfd_malloc (len);
4490       if (stub_name == NULL)
4491         return stub_name;
4492
4493       len = sprintf (stub_name, "%08x.%x:%x+%x",
4494                      input_section->id & 0xffffffff,
4495                      sym_sec->id & 0xffffffff,
4496                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4497                      (int) rel->r_addend & 0xffffffff);
4498     }
4499   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4500     stub_name[len - 2] = 0;
4501   return stub_name;
4502 }
4503
4504 /* Look up an entry in the stub hash.  Stub entries are cached because
4505    creating the stub name takes a bit of time.  */
4506
4507 static struct ppc_stub_hash_entry *
4508 ppc_get_stub_entry (const asection *input_section,
4509                     const asection *sym_sec,
4510                     struct ppc_link_hash_entry *h,
4511                     const Elf_Internal_Rela *rel,
4512                     struct ppc_link_hash_table *htab)
4513 {
4514   struct ppc_stub_hash_entry *stub_entry;
4515   struct map_stub *group;
4516
4517   /* If this input section is part of a group of sections sharing one
4518      stub section, then use the id of the first section in the group.
4519      Stub names need to include a section id, as there may well be
4520      more than one stub used to reach say, printf, and we need to
4521      distinguish between them.  */
4522   group = htab->sec_info[input_section->id].u.group;
4523   if (group == NULL)
4524     return NULL;
4525
4526   if (h != NULL && h->u.stub_cache != NULL
4527       && h->u.stub_cache->h == h
4528       && h->u.stub_cache->group == group)
4529     {
4530       stub_entry = h->u.stub_cache;
4531     }
4532   else
4533     {
4534       char *stub_name;
4535
4536       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4537       if (stub_name == NULL)
4538         return NULL;
4539
4540       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4541                                          stub_name, FALSE, FALSE);
4542       if (h != NULL)
4543         h->u.stub_cache = stub_entry;
4544
4545       free (stub_name);
4546     }
4547
4548   return stub_entry;
4549 }
4550
4551 /* Add a new stub entry to the stub hash.  Not all fields of the new
4552    stub entry are initialised.  */
4553
4554 static struct ppc_stub_hash_entry *
4555 ppc_add_stub (const char *stub_name,
4556               asection *section,
4557               struct bfd_link_info *info)
4558 {
4559   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4560   struct map_stub *group;
4561   asection *link_sec;
4562   asection *stub_sec;
4563   struct ppc_stub_hash_entry *stub_entry;
4564
4565   group = htab->sec_info[section->id].u.group;
4566   link_sec = group->link_sec;
4567   stub_sec = group->stub_sec;
4568   if (stub_sec == NULL)
4569     {
4570       size_t namelen;
4571       bfd_size_type len;
4572       char *s_name;
4573
4574       namelen = strlen (link_sec->name);
4575       len = namelen + sizeof (STUB_SUFFIX);
4576       s_name = bfd_alloc (htab->params->stub_bfd, len);
4577       if (s_name == NULL)
4578         return NULL;
4579
4580       memcpy (s_name, link_sec->name, namelen);
4581       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4582       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4583       if (stub_sec == NULL)
4584         return NULL;
4585       group->stub_sec = stub_sec;
4586     }
4587
4588   /* Enter this entry into the linker stub hash table.  */
4589   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4590                                      TRUE, FALSE);
4591   if (stub_entry == NULL)
4592     {
4593       /* xgettext:c-format */
4594       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4595                               section->owner, stub_name);
4596       return NULL;
4597     }
4598
4599   stub_entry->group = group;
4600   stub_entry->stub_offset = 0;
4601   return stub_entry;
4602 }
4603
4604 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4605    not already done.  */
4606
4607 static bfd_boolean
4608 create_got_section (bfd *abfd, struct bfd_link_info *info)
4609 {
4610   asection *got, *relgot;
4611   flagword flags;
4612   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4613
4614   if (!is_ppc64_elf (abfd))
4615     return FALSE;
4616   if (htab == NULL)
4617     return FALSE;
4618
4619   if (!htab->elf.sgot
4620       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4621     return FALSE;
4622
4623   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4624            | SEC_LINKER_CREATED);
4625
4626   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4627   if (!got
4628       || !bfd_set_section_alignment (abfd, got, 3))
4629     return FALSE;
4630
4631   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4632                                                flags | SEC_READONLY);
4633   if (!relgot
4634       || ! bfd_set_section_alignment (abfd, relgot, 3))
4635     return FALSE;
4636
4637   ppc64_elf_tdata (abfd)->got = got;
4638   ppc64_elf_tdata (abfd)->relgot = relgot;
4639   return TRUE;
4640 }
4641
4642 /* Create the dynamic sections, and set up shortcuts.  */
4643
4644 static bfd_boolean
4645 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4646 {
4647   struct ppc_link_hash_table *htab;
4648
4649   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4650     return FALSE;
4651
4652   htab = ppc_hash_table (info);
4653   if (htab == NULL)
4654     return FALSE;
4655
4656   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4657   if (!bfd_link_pic (info))
4658     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4659
4660   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4661       || (!bfd_link_pic (info) && !htab->relbss))
4662     abort ();
4663
4664   return TRUE;
4665 }
4666
4667 /* Follow indirect and warning symbol links.  */
4668
4669 static inline struct bfd_link_hash_entry *
4670 follow_link (struct bfd_link_hash_entry *h)
4671 {
4672   while (h->type == bfd_link_hash_indirect
4673          || h->type == bfd_link_hash_warning)
4674     h = h->u.i.link;
4675   return h;
4676 }
4677
4678 static inline struct elf_link_hash_entry *
4679 elf_follow_link (struct elf_link_hash_entry *h)
4680 {
4681   return (struct elf_link_hash_entry *) follow_link (&h->root);
4682 }
4683
4684 static inline struct ppc_link_hash_entry *
4685 ppc_follow_link (struct ppc_link_hash_entry *h)
4686 {
4687   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4688 }
4689
4690 /* Merge PLT info on FROM with that on TO.  */
4691
4692 static void
4693 move_plt_plist (struct ppc_link_hash_entry *from,
4694                 struct ppc_link_hash_entry *to)
4695 {
4696   if (from->elf.plt.plist != NULL)
4697     {
4698       if (to->elf.plt.plist != NULL)
4699         {
4700           struct plt_entry **entp;
4701           struct plt_entry *ent;
4702
4703           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4704             {
4705               struct plt_entry *dent;
4706
4707               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4708                 if (dent->addend == ent->addend)
4709                   {
4710                     dent->plt.refcount += ent->plt.refcount;
4711                     *entp = ent->next;
4712                     break;
4713                   }
4714               if (dent == NULL)
4715                 entp = &ent->next;
4716             }
4717           *entp = to->elf.plt.plist;
4718         }
4719
4720       to->elf.plt.plist = from->elf.plt.plist;
4721       from->elf.plt.plist = NULL;
4722     }
4723 }
4724
4725 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4726
4727 static void
4728 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4729                                 struct elf_link_hash_entry *dir,
4730                                 struct elf_link_hash_entry *ind)
4731 {
4732   struct ppc_link_hash_entry *edir, *eind;
4733
4734   edir = (struct ppc_link_hash_entry *) dir;
4735   eind = (struct ppc_link_hash_entry *) ind;
4736
4737   edir->is_func |= eind->is_func;
4738   edir->is_func_descriptor |= eind->is_func_descriptor;
4739   edir->tls_mask |= eind->tls_mask;
4740   if (eind->oh != NULL)
4741     edir->oh = ppc_follow_link (eind->oh);
4742
4743   if (edir->elf.versioned != versioned_hidden)
4744     {
4745       /* If called to transfer flags for a weakdef during processing
4746          of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4747          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4748       if (!(ELIMINATE_COPY_RELOCS
4749             && eind->elf.root.type != bfd_link_hash_indirect
4750             && edir->elf.dynamic_adjusted))
4751         edir->elf.non_got_ref |= eind->elf.non_got_ref;
4752
4753       edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4754       edir->elf.ref_regular |= eind->elf.ref_regular;
4755       edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4756       edir->elf.needs_plt |= eind->elf.needs_plt;
4757       edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4758     }
4759
4760   /* If we were called to copy over info for a weak sym, don't copy
4761      dyn_relocs, plt/got info, or dynindx.  We used to copy dyn_relocs
4762      in order to simplify readonly_dynrelocs and save a field in the
4763      symbol hash entry, but that means dyn_relocs can't be used in any
4764      tests about a specific symbol, or affect other symbol flags which
4765      are then tested.
4766      Chain weakdefs so we can get from the weakdef back to an alias.
4767      The list is circular so that we don't need to use u.weakdef as
4768      well as this list to look at all aliases.  */
4769   if (eind->elf.root.type != bfd_link_hash_indirect)
4770     {
4771       struct ppc_link_hash_entry *cur, *add, *next;
4772
4773       add = eind;
4774       do
4775         {
4776           cur = edir->weakref;
4777           if (cur != NULL)
4778             {
4779               do
4780                 {
4781                   /* We can be called twice for the same symbols.
4782                      Don't make multiple loops.  */
4783                   if (cur == add)
4784                     return;
4785                   cur = cur->weakref;
4786                 } while (cur != edir);
4787             }
4788           next = add->weakref;
4789           if (cur != add)
4790             {
4791               add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4792               edir->weakref = add;
4793             }
4794           add = next;
4795         } while (add != NULL && add != eind);
4796       return;
4797     }
4798
4799   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4800   if (eind->dyn_relocs != NULL)
4801     {
4802       if (edir->dyn_relocs != NULL)
4803         {
4804           struct elf_dyn_relocs **pp;
4805           struct elf_dyn_relocs *p;
4806
4807           /* Add reloc counts against the indirect sym to the direct sym
4808              list.  Merge any entries against the same section.  */
4809           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4810             {
4811               struct elf_dyn_relocs *q;
4812
4813               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4814                 if (q->sec == p->sec)
4815                   {
4816                     q->pc_count += p->pc_count;
4817                     q->count += p->count;
4818                     *pp = p->next;
4819                     break;
4820                   }
4821               if (q == NULL)
4822                 pp = &p->next;
4823             }
4824           *pp = edir->dyn_relocs;
4825         }
4826
4827       edir->dyn_relocs = eind->dyn_relocs;
4828       eind->dyn_relocs = NULL;
4829     }
4830
4831   /* Copy over got entries that we may have already seen to the
4832      symbol which just became indirect.  */
4833   if (eind->elf.got.glist != NULL)
4834     {
4835       if (edir->elf.got.glist != NULL)
4836         {
4837           struct got_entry **entp;
4838           struct got_entry *ent;
4839
4840           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4841             {
4842               struct got_entry *dent;
4843
4844               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4845                 if (dent->addend == ent->addend
4846                     && dent->owner == ent->owner
4847                     && dent->tls_type == ent->tls_type)
4848                   {
4849                     dent->got.refcount += ent->got.refcount;
4850                     *entp = ent->next;
4851                     break;
4852                   }
4853               if (dent == NULL)
4854                 entp = &ent->next;
4855             }
4856           *entp = edir->elf.got.glist;
4857         }
4858
4859       edir->elf.got.glist = eind->elf.got.glist;
4860       eind->elf.got.glist = NULL;
4861     }
4862
4863   /* And plt entries.  */
4864   move_plt_plist (eind, edir);
4865
4866   if (eind->elf.dynindx != -1)
4867     {
4868       if (edir->elf.dynindx != -1)
4869         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4870                                 edir->elf.dynstr_index);
4871       edir->elf.dynindx = eind->elf.dynindx;
4872       edir->elf.dynstr_index = eind->elf.dynstr_index;
4873       eind->elf.dynindx = -1;
4874       eind->elf.dynstr_index = 0;
4875     }
4876 }
4877
4878 /* Find the function descriptor hash entry from the given function code
4879    hash entry FH.  Link the entries via their OH fields.  */
4880
4881 static struct ppc_link_hash_entry *
4882 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4883 {
4884   struct ppc_link_hash_entry *fdh = fh->oh;
4885
4886   if (fdh == NULL)
4887     {
4888       const char *fd_name = fh->elf.root.root.string + 1;
4889
4890       fdh = (struct ppc_link_hash_entry *)
4891         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4892       if (fdh == NULL)
4893         return fdh;
4894
4895       fdh->is_func_descriptor = 1;
4896       fdh->oh = fh;
4897       fh->is_func = 1;
4898       fh->oh = fdh;
4899     }
4900
4901   return ppc_follow_link (fdh);
4902 }
4903
4904 /* Make a fake function descriptor sym for the code sym FH.  */
4905
4906 static struct ppc_link_hash_entry *
4907 make_fdh (struct bfd_link_info *info,
4908           struct ppc_link_hash_entry *fh)
4909 {
4910   bfd *abfd;
4911   asymbol *newsym;
4912   struct bfd_link_hash_entry *bh;
4913   struct ppc_link_hash_entry *fdh;
4914
4915   abfd = fh->elf.root.u.undef.abfd;
4916   newsym = bfd_make_empty_symbol (abfd);
4917   newsym->name = fh->elf.root.root.string + 1;
4918   newsym->section = bfd_und_section_ptr;
4919   newsym->value = 0;
4920   newsym->flags = BSF_WEAK;
4921
4922   bh = NULL;
4923   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4924                                          newsym->flags, newsym->section,
4925                                          newsym->value, NULL, FALSE, FALSE,
4926                                          &bh))
4927     return NULL;
4928
4929   fdh = (struct ppc_link_hash_entry *) bh;
4930   fdh->elf.non_elf = 0;
4931   fdh->fake = 1;
4932   fdh->is_func_descriptor = 1;
4933   fdh->oh = fh;
4934   fh->is_func = 1;
4935   fh->oh = fdh;
4936   return fdh;
4937 }
4938
4939 /* Fix function descriptor symbols defined in .opd sections to be
4940    function type.  */
4941
4942 static bfd_boolean
4943 ppc64_elf_add_symbol_hook (bfd *ibfd,
4944                            struct bfd_link_info *info,
4945                            Elf_Internal_Sym *isym,
4946                            const char **name,
4947                            flagword *flags ATTRIBUTE_UNUSED,
4948                            asection **sec,
4949                            bfd_vma *value)
4950 {
4951   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4952       && (ibfd->flags & DYNAMIC) == 0
4953       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4954     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4955
4956   if (*sec != NULL
4957       && strcmp ((*sec)->name, ".opd") == 0)
4958     {
4959       asection *code_sec;
4960
4961       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4962             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4963         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4964
4965       /* If the symbol is a function defined in .opd, and the function
4966          code is in a discarded group, let it appear to be undefined.  */
4967       if (!bfd_link_relocatable (info)
4968           && (*sec)->reloc_count != 0
4969           && opd_entry_value (*sec, *value, &code_sec, NULL,
4970                               FALSE) != (bfd_vma) -1
4971           && discarded_section (code_sec))
4972         {
4973           *sec = bfd_und_section_ptr;
4974           isym->st_shndx = SHN_UNDEF;
4975         }
4976     }
4977   else if (*sec != NULL
4978            && strcmp ((*sec)->name, ".toc") == 0
4979            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4980     {
4981       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4982       if (htab != NULL)
4983         htab->params->object_in_toc = 1;
4984     }
4985
4986   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4987     {
4988       if (abiversion (ibfd) == 0)
4989         set_abiversion (ibfd, 2);
4990       else if (abiversion (ibfd) == 1)
4991         {
4992           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4993                                     " for ABI version 1\n"), name);
4994           bfd_set_error (bfd_error_bad_value);
4995           return FALSE;
4996         }
4997     }
4998
4999   return TRUE;
5000 }
5001
5002 /* Merge non-visibility st_other attributes: local entry point.  */
5003
5004 static void
5005 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5006                                   const Elf_Internal_Sym *isym,
5007                                   bfd_boolean definition,
5008                                   bfd_boolean dynamic)
5009 {
5010   if (definition && !dynamic)
5011     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5012                 | ELF_ST_VISIBILITY (h->other));
5013 }
5014
5015 /* This function makes an old ABI object reference to ".bar" cause the
5016    inclusion of a new ABI object archive that defines "bar".
5017    NAME is a symbol defined in an archive.  Return a symbol in the hash
5018    table that might be satisfied by the archive symbols.  */
5019
5020 static struct elf_link_hash_entry *
5021 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5022                                  struct bfd_link_info *info,
5023                                  const char *name)
5024 {
5025   struct elf_link_hash_entry *h;
5026   char *dot_name;
5027   size_t len;
5028
5029   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5030   if (h != NULL
5031       /* Don't return this sym if it is a fake function descriptor
5032          created by add_symbol_adjust.  */
5033       && !(h->root.type == bfd_link_hash_undefweak
5034            && ((struct ppc_link_hash_entry *) h)->fake))
5035     return h;
5036
5037   if (name[0] == '.')
5038     return h;
5039
5040   len = strlen (name);
5041   dot_name = bfd_alloc (abfd, len + 2);
5042   if (dot_name == NULL)
5043     return (struct elf_link_hash_entry *) 0 - 1;
5044   dot_name[0] = '.';
5045   memcpy (dot_name + 1, name, len + 1);
5046   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5047   bfd_release (abfd, dot_name);
5048   return h;
5049 }
5050
5051 /* This function satisfies all old ABI object references to ".bar" if a
5052    new ABI object defines "bar".  Well, at least, undefined dot symbols
5053    are made weak.  This stops later archive searches from including an
5054    object if we already have a function descriptor definition.  It also
5055    prevents the linker complaining about undefined symbols.
5056    We also check and correct mismatched symbol visibility here.  The
5057    most restrictive visibility of the function descriptor and the
5058    function entry symbol is used.  */
5059
5060 static bfd_boolean
5061 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5062 {
5063   struct ppc_link_hash_table *htab;
5064   struct ppc_link_hash_entry *fdh;
5065
5066   if (eh->elf.root.type == bfd_link_hash_warning)
5067     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5068
5069   if (eh->elf.root.type == bfd_link_hash_indirect)
5070     return TRUE;
5071
5072   if (eh->elf.root.root.string[0] != '.')
5073     abort ();
5074
5075   htab = ppc_hash_table (info);
5076   if (htab == NULL)
5077     return FALSE;
5078
5079   fdh = lookup_fdh (eh, htab);
5080   if (fdh == NULL)
5081     {
5082       if (!bfd_link_relocatable (info)
5083           && (eh->elf.root.type == bfd_link_hash_undefined
5084               || eh->elf.root.type == bfd_link_hash_undefweak)
5085           && eh->elf.ref_regular)
5086         {
5087           /* Make an undefweak function descriptor sym, which is enough to
5088              pull in an --as-needed shared lib, but won't cause link
5089              errors.  Archives are handled elsewhere.  */
5090           fdh = make_fdh (info, eh);
5091           if (fdh == NULL)
5092             return FALSE;
5093           fdh->elf.ref_regular = 1;
5094         }
5095     }
5096   else
5097     {
5098       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5099       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5100       if (entry_vis < descr_vis)
5101         fdh->elf.other += entry_vis - descr_vis;
5102       else if (entry_vis > descr_vis)
5103         eh->elf.other += descr_vis - entry_vis;
5104
5105       if ((fdh->elf.root.type == bfd_link_hash_defined
5106            || fdh->elf.root.type == bfd_link_hash_defweak)
5107           && eh->elf.root.type == bfd_link_hash_undefined)
5108         {
5109           eh->elf.root.type = bfd_link_hash_undefweak;
5110           eh->was_undefined = 1;
5111           htab->twiddled_syms = 1;
5112         }
5113     }
5114
5115   return TRUE;
5116 }
5117
5118 /* Set up opd section info and abiversion for IBFD, and process list
5119    of dot-symbols we made in link_hash_newfunc.  */
5120
5121 static bfd_boolean
5122 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5123 {
5124   struct ppc_link_hash_table *htab;
5125   struct ppc_link_hash_entry **p, *eh;
5126   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5127
5128   if (opd != NULL && opd->size != 0)
5129     {
5130       if (abiversion (ibfd) == 0)
5131         set_abiversion (ibfd, 1);
5132       else if (abiversion (ibfd) >= 2)
5133         {
5134           /* xgettext:c-format */
5135           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5136                                     " version %d\n"),
5137                                   ibfd, abiversion (ibfd));
5138           bfd_set_error (bfd_error_bad_value);
5139           return FALSE;
5140         }
5141
5142       if ((ibfd->flags & DYNAMIC) == 0
5143           && (opd->flags & SEC_RELOC) != 0
5144           && opd->reloc_count != 0
5145           && !bfd_is_abs_section (opd->output_section))
5146         {
5147           /* Garbage collection needs some extra help with .opd sections.
5148              We don't want to necessarily keep everything referenced by
5149              relocs in .opd, as that would keep all functions.  Instead,
5150              if we reference an .opd symbol (a function descriptor), we
5151              want to keep the function code symbol's section.  This is
5152              easy for global symbols, but for local syms we need to keep
5153              information about the associated function section.  */
5154           bfd_size_type amt;
5155           asection **opd_sym_map;
5156
5157           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5158           opd_sym_map = bfd_zalloc (ibfd, amt);
5159           if (opd_sym_map == NULL)
5160             return FALSE;
5161           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5162           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5163           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5164         }
5165     }
5166
5167   if (!is_ppc64_elf (info->output_bfd))
5168     return TRUE;
5169   htab = ppc_hash_table (info);
5170   if (htab == NULL)
5171     return FALSE;
5172
5173   /* For input files without an explicit abiversion in e_flags
5174      we should have flagged any with symbol st_other bits set
5175      as ELFv1 and above flagged those with .opd as ELFv2.
5176      Set the output abiversion if not yet set, and for any input
5177      still ambiguous, take its abiversion from the output.
5178      Differences in ABI are reported later.  */
5179   if (abiversion (info->output_bfd) == 0)
5180     set_abiversion (info->output_bfd, abiversion (ibfd));
5181   else if (abiversion (ibfd) == 0)
5182     set_abiversion (ibfd, abiversion (info->output_bfd));
5183
5184   p = &htab->dot_syms;
5185   while ((eh = *p) != NULL)
5186     {
5187       *p = NULL;
5188       if (&eh->elf == htab->elf.hgot)
5189         ;
5190       else if (htab->elf.hgot == NULL
5191                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5192         htab->elf.hgot = &eh->elf;
5193       else if (!add_symbol_adjust (eh, info))
5194         return FALSE;
5195       p = &eh->u.next_dot_sym;
5196     }
5197
5198   /* We need to fix the undefs list for any syms we have twiddled to
5199      undefweak.  */
5200   if (htab->twiddled_syms)
5201     {
5202       bfd_link_repair_undef_list (&htab->elf.root);
5203       htab->twiddled_syms = 0;
5204     }
5205   return TRUE;
5206 }
5207
5208 /* Undo hash table changes when an --as-needed input file is determined
5209    not to be needed.  */
5210
5211 static bfd_boolean
5212 ppc64_elf_notice_as_needed (bfd *ibfd,
5213                             struct bfd_link_info *info,
5214                             enum notice_asneeded_action act)
5215 {
5216   if (act == notice_not_needed)
5217     {
5218       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5219
5220       if (htab == NULL)
5221         return FALSE;
5222
5223       htab->dot_syms = NULL;
5224     }
5225   return _bfd_elf_notice_as_needed (ibfd, info, act);
5226 }
5227
5228 /* If --just-symbols against a final linked binary, then assume we need
5229    toc adjusting stubs when calling functions defined there.  */
5230
5231 static void
5232 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5233 {
5234   if ((sec->flags & SEC_CODE) != 0
5235       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5236       && is_ppc64_elf (sec->owner))
5237     {
5238       if (abiversion (sec->owner) >= 2
5239           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5240         sec->has_toc_reloc = 1;
5241     }
5242   _bfd_elf_link_just_syms (sec, info);
5243 }
5244
5245 static struct plt_entry **
5246 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5247                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5248 {
5249   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5250   struct plt_entry **local_plt;
5251   unsigned char *local_got_tls_masks;
5252
5253   if (local_got_ents == NULL)
5254     {
5255       bfd_size_type size = symtab_hdr->sh_info;
5256
5257       size *= (sizeof (*local_got_ents)
5258                + sizeof (*local_plt)
5259                + sizeof (*local_got_tls_masks));
5260       local_got_ents = bfd_zalloc (abfd, size);
5261       if (local_got_ents == NULL)
5262         return NULL;
5263       elf_local_got_ents (abfd) = local_got_ents;
5264     }
5265
5266   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5267     {
5268       struct got_entry *ent;
5269
5270       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5271         if (ent->addend == r_addend
5272             && ent->owner == abfd
5273             && ent->tls_type == tls_type)
5274           break;
5275       if (ent == NULL)
5276         {
5277           bfd_size_type amt = sizeof (*ent);
5278           ent = bfd_alloc (abfd, amt);
5279           if (ent == NULL)
5280             return FALSE;
5281           ent->next = local_got_ents[r_symndx];
5282           ent->addend = r_addend;
5283           ent->owner = abfd;
5284           ent->tls_type = tls_type;
5285           ent->is_indirect = FALSE;
5286           ent->got.refcount = 0;
5287           local_got_ents[r_symndx] = ent;
5288         }
5289       ent->got.refcount += 1;
5290     }
5291
5292   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5293   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5294   local_got_tls_masks[r_symndx] |= tls_type;
5295
5296   return local_plt + r_symndx;
5297 }
5298
5299 static bfd_boolean
5300 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5301 {
5302   struct plt_entry *ent;
5303
5304   for (ent = *plist; ent != NULL; ent = ent->next)
5305     if (ent->addend == addend)
5306       break;
5307   if (ent == NULL)
5308     {
5309       bfd_size_type amt = sizeof (*ent);
5310       ent = bfd_alloc (abfd, amt);
5311       if (ent == NULL)
5312         return FALSE;
5313       ent->next = *plist;
5314       ent->addend = addend;
5315       ent->plt.refcount = 0;
5316       *plist = ent;
5317     }
5318   ent->plt.refcount += 1;
5319   return TRUE;
5320 }
5321
5322 static bfd_boolean
5323 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5324 {
5325   return (r_type == R_PPC64_REL24
5326           || r_type == R_PPC64_REL14
5327           || r_type == R_PPC64_REL14_BRTAKEN
5328           || r_type == R_PPC64_REL14_BRNTAKEN
5329           || r_type == R_PPC64_ADDR24
5330           || r_type == R_PPC64_ADDR14
5331           || r_type == R_PPC64_ADDR14_BRTAKEN
5332           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5333 }
5334
5335 /* Look through the relocs for a section during the first phase, and
5336    calculate needed space in the global offset table, procedure
5337    linkage table, and dynamic reloc sections.  */
5338
5339 static bfd_boolean
5340 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5341                         asection *sec, const Elf_Internal_Rela *relocs)
5342 {
5343   struct ppc_link_hash_table *htab;
5344   Elf_Internal_Shdr *symtab_hdr;
5345   struct elf_link_hash_entry **sym_hashes;
5346   const Elf_Internal_Rela *rel;
5347   const Elf_Internal_Rela *rel_end;
5348   asection *sreloc;
5349   asection **opd_sym_map;
5350   struct elf_link_hash_entry *tga, *dottga;
5351
5352   if (bfd_link_relocatable (info))
5353     return TRUE;
5354
5355   /* Don't do anything special with non-loaded, non-alloced sections.
5356      In particular, any relocs in such sections should not affect GOT
5357      and PLT reference counting (ie. we don't allow them to create GOT
5358      or PLT entries), there's no possibility or desire to optimize TLS
5359      relocs, and there's not much point in propagating relocs to shared
5360      libs that the dynamic linker won't relocate.  */
5361   if ((sec->flags & SEC_ALLOC) == 0)
5362     return TRUE;
5363
5364   BFD_ASSERT (is_ppc64_elf (abfd));
5365
5366   htab = ppc_hash_table (info);
5367   if (htab == NULL)
5368     return FALSE;
5369
5370   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5371                               FALSE, FALSE, TRUE);
5372   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5373                                  FALSE, FALSE, TRUE);
5374   symtab_hdr = &elf_symtab_hdr (abfd);
5375   sym_hashes = elf_sym_hashes (abfd);
5376   sreloc = NULL;
5377   opd_sym_map = NULL;
5378   if (ppc64_elf_section_data (sec) != NULL
5379       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5380     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5381
5382   rel_end = relocs + sec->reloc_count;
5383   for (rel = relocs; rel < rel_end; rel++)
5384     {
5385       unsigned long r_symndx;
5386       struct elf_link_hash_entry *h;
5387       enum elf_ppc64_reloc_type r_type;
5388       int tls_type;
5389       struct _ppc64_elf_section_data *ppc64_sec;
5390       struct plt_entry **ifunc, **plt_list;
5391
5392       r_symndx = ELF64_R_SYM (rel->r_info);
5393       if (r_symndx < symtab_hdr->sh_info)
5394         h = NULL;
5395       else
5396         {
5397           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5398           h = elf_follow_link (h);
5399
5400           /* PR15323, ref flags aren't set for references in the same
5401              object.  */
5402           h->root.non_ir_ref = 1;
5403
5404           if (h == htab->elf.hgot)
5405             sec->has_toc_reloc = 1;
5406         }
5407
5408       tls_type = 0;
5409       ifunc = NULL;
5410       if (h != NULL)
5411         {
5412           if (h->type == STT_GNU_IFUNC)
5413             {
5414               h->needs_plt = 1;
5415               ifunc = &h->plt.plist;
5416             }
5417         }
5418       else
5419         {
5420           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5421                                                           abfd, r_symndx);
5422           if (isym == NULL)
5423             return FALSE;
5424
5425           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5426             {
5427               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5428                                              rel->r_addend, PLT_IFUNC);
5429               if (ifunc == NULL)
5430                 return FALSE;
5431             }
5432         }
5433
5434       r_type = ELF64_R_TYPE (rel->r_info);
5435       switch (r_type)
5436         {
5437         case R_PPC64_TLSGD:
5438         case R_PPC64_TLSLD:
5439           /* These special tls relocs tie a call to __tls_get_addr with
5440              its parameter symbol.  */
5441           break;
5442
5443         case R_PPC64_GOT_TLSLD16:
5444         case R_PPC64_GOT_TLSLD16_LO:
5445         case R_PPC64_GOT_TLSLD16_HI:
5446         case R_PPC64_GOT_TLSLD16_HA:
5447           tls_type = TLS_TLS | TLS_LD;
5448           goto dogottls;
5449
5450         case R_PPC64_GOT_TLSGD16:
5451         case R_PPC64_GOT_TLSGD16_LO:
5452         case R_PPC64_GOT_TLSGD16_HI:
5453         case R_PPC64_GOT_TLSGD16_HA:
5454           tls_type = TLS_TLS | TLS_GD;
5455           goto dogottls;
5456
5457         case R_PPC64_GOT_TPREL16_DS:
5458         case R_PPC64_GOT_TPREL16_LO_DS:
5459         case R_PPC64_GOT_TPREL16_HI:
5460         case R_PPC64_GOT_TPREL16_HA:
5461           if (bfd_link_pic (info))
5462             info->flags |= DF_STATIC_TLS;
5463           tls_type = TLS_TLS | TLS_TPREL;
5464           goto dogottls;
5465
5466         case R_PPC64_GOT_DTPREL16_DS:
5467         case R_PPC64_GOT_DTPREL16_LO_DS:
5468         case R_PPC64_GOT_DTPREL16_HI:
5469         case R_PPC64_GOT_DTPREL16_HA:
5470           tls_type = TLS_TLS | TLS_DTPREL;
5471         dogottls:
5472           sec->has_tls_reloc = 1;
5473           /* Fall through */
5474
5475         case R_PPC64_GOT16:
5476         case R_PPC64_GOT16_DS:
5477         case R_PPC64_GOT16_HA:
5478         case R_PPC64_GOT16_HI:
5479         case R_PPC64_GOT16_LO:
5480         case R_PPC64_GOT16_LO_DS:
5481           /* This symbol requires a global offset table entry.  */
5482           sec->has_toc_reloc = 1;
5483           if (r_type == R_PPC64_GOT_TLSLD16
5484               || r_type == R_PPC64_GOT_TLSGD16
5485               || r_type == R_PPC64_GOT_TPREL16_DS
5486               || r_type == R_PPC64_GOT_DTPREL16_DS
5487               || r_type == R_PPC64_GOT16
5488               || r_type == R_PPC64_GOT16_DS)
5489             {
5490               htab->do_multi_toc = 1;
5491               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5492             }
5493
5494           if (ppc64_elf_tdata (abfd)->got == NULL
5495               && !create_got_section (abfd, info))
5496             return FALSE;
5497
5498           if (h != NULL)
5499             {
5500               struct ppc_link_hash_entry *eh;
5501               struct got_entry *ent;
5502
5503               eh = (struct ppc_link_hash_entry *) h;
5504               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5505                 if (ent->addend == rel->r_addend
5506                     && ent->owner == abfd
5507                     && ent->tls_type == tls_type)
5508                   break;
5509               if (ent == NULL)
5510                 {
5511                   bfd_size_type amt = sizeof (*ent);
5512                   ent = bfd_alloc (abfd, amt);
5513                   if (ent == NULL)
5514                     return FALSE;
5515                   ent->next = eh->elf.got.glist;
5516                   ent->addend = rel->r_addend;
5517                   ent->owner = abfd;
5518                   ent->tls_type = tls_type;
5519                   ent->is_indirect = FALSE;
5520                   ent->got.refcount = 0;
5521                   eh->elf.got.glist = ent;
5522                 }
5523               ent->got.refcount += 1;
5524               eh->tls_mask |= tls_type;
5525             }
5526           else
5527             /* This is a global offset table entry for a local symbol.  */
5528             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5529                                         rel->r_addend, tls_type))
5530               return FALSE;
5531
5532           /* We may also need a plt entry if the symbol turns out to be
5533              an ifunc.  */
5534           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5535             {
5536               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5537                 return FALSE;
5538             }
5539           break;
5540
5541         case R_PPC64_PLT16_HA:
5542         case R_PPC64_PLT16_HI:
5543         case R_PPC64_PLT16_LO:
5544         case R_PPC64_PLT32:
5545         case R_PPC64_PLT64:
5546           /* This symbol requires a procedure linkage table entry.  */
5547           plt_list = ifunc;
5548           if (h != NULL)
5549             {
5550               h->needs_plt = 1;
5551               if (h->root.root.string[0] == '.'
5552                   && h->root.root.string[1] != '\0')
5553                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5554               plt_list = &h->plt.plist;
5555             }
5556           if (plt_list == NULL)
5557             {
5558               /* It does not make sense to have a procedure linkage
5559                  table entry for a non-ifunc local symbol.  */
5560               info->callbacks->einfo
5561                 /* xgettext:c-format */
5562                 (_("%P: %H: %s reloc against local symbol\n"),
5563                  abfd, sec, rel->r_offset,
5564                  ppc64_elf_howto_table[r_type]->name);
5565               bfd_set_error (bfd_error_bad_value);
5566               return FALSE;
5567             }
5568           if (!update_plt_info (abfd, plt_list, rel->r_addend))
5569             return FALSE;
5570           break;
5571
5572           /* The following relocations don't need to propagate the
5573              relocation if linking a shared object since they are
5574              section relative.  */
5575         case R_PPC64_SECTOFF:
5576         case R_PPC64_SECTOFF_LO:
5577         case R_PPC64_SECTOFF_HI:
5578         case R_PPC64_SECTOFF_HA:
5579         case R_PPC64_SECTOFF_DS:
5580         case R_PPC64_SECTOFF_LO_DS:
5581         case R_PPC64_DTPREL16:
5582         case R_PPC64_DTPREL16_LO:
5583         case R_PPC64_DTPREL16_HI:
5584         case R_PPC64_DTPREL16_HA:
5585         case R_PPC64_DTPREL16_DS:
5586         case R_PPC64_DTPREL16_LO_DS:
5587         case R_PPC64_DTPREL16_HIGH:
5588         case R_PPC64_DTPREL16_HIGHA:
5589         case R_PPC64_DTPREL16_HIGHER:
5590         case R_PPC64_DTPREL16_HIGHERA:
5591         case R_PPC64_DTPREL16_HIGHEST:
5592         case R_PPC64_DTPREL16_HIGHESTA:
5593           break;
5594
5595           /* Nor do these.  */
5596         case R_PPC64_REL16:
5597         case R_PPC64_REL16_LO:
5598         case R_PPC64_REL16_HI:
5599         case R_PPC64_REL16_HA:
5600         case R_PPC64_REL16DX_HA:
5601           break;
5602
5603           /* Not supported as a dynamic relocation.  */
5604         case R_PPC64_ADDR64_LOCAL:
5605           if (bfd_link_pic (info))
5606             {
5607               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5608                 ppc_howto_init ();
5609               /* xgettext:c-format */
5610               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5611                                         "in shared libraries and PIEs.\n"),
5612                                       abfd, sec, rel->r_offset,
5613                                       ppc64_elf_howto_table[r_type]->name);
5614               bfd_set_error (bfd_error_bad_value);
5615               return FALSE;
5616             }
5617           break;
5618
5619         case R_PPC64_TOC16:
5620         case R_PPC64_TOC16_DS:
5621           htab->do_multi_toc = 1;
5622           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5623           /* Fall through.  */
5624         case R_PPC64_TOC16_LO:
5625         case R_PPC64_TOC16_HI:
5626         case R_PPC64_TOC16_HA:
5627         case R_PPC64_TOC16_LO_DS:
5628           sec->has_toc_reloc = 1;
5629           break;
5630
5631           /* Marker reloc.  */
5632         case R_PPC64_ENTRY:
5633           break;
5634
5635           /* This relocation describes the C++ object vtable hierarchy.
5636              Reconstruct it for later use during GC.  */
5637         case R_PPC64_GNU_VTINHERIT:
5638           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5639             return FALSE;
5640           break;
5641
5642           /* This relocation describes which C++ vtable entries are actually
5643              used.  Record for later use during GC.  */
5644         case R_PPC64_GNU_VTENTRY:
5645           BFD_ASSERT (h != NULL);
5646           if (h != NULL
5647               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5648             return FALSE;
5649           break;
5650
5651         case R_PPC64_REL14:
5652         case R_PPC64_REL14_BRTAKEN:
5653         case R_PPC64_REL14_BRNTAKEN:
5654           {
5655             asection *dest = NULL;
5656
5657             /* Heuristic: If jumping outside our section, chances are
5658                we are going to need a stub.  */
5659             if (h != NULL)
5660               {
5661                 /* If the sym is weak it may be overridden later, so
5662                    don't assume we know where a weak sym lives.  */
5663                 if (h->root.type == bfd_link_hash_defined)
5664                   dest = h->root.u.def.section;
5665               }
5666             else
5667               {
5668                 Elf_Internal_Sym *isym;
5669
5670                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5671                                               abfd, r_symndx);
5672                 if (isym == NULL)
5673                   return FALSE;
5674
5675                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5676               }
5677
5678             if (dest != sec)
5679               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5680           }
5681           /* Fall through.  */
5682
5683         case R_PPC64_REL24:
5684           plt_list = ifunc;
5685           if (h != NULL)
5686             {
5687               h->needs_plt = 1;
5688               if (h->root.root.string[0] == '.'
5689                   && h->root.root.string[1] != '\0')
5690                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5691
5692               if (h == tga || h == dottga)
5693                 {
5694                   sec->has_tls_reloc = 1;
5695                   if (rel != relocs
5696                       && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5697                           || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5698                     /* We have a new-style __tls_get_addr call with
5699                        a marker reloc.  */
5700                     ;
5701                   else
5702                     /* Mark this section as having an old-style call.  */
5703                     sec->has_tls_get_addr_call = 1;
5704                 }
5705               plt_list = &h->plt.plist;
5706             }
5707
5708           /* We may need a .plt entry if the function this reloc
5709              refers to is in a shared lib.  */
5710           if (plt_list
5711               && !update_plt_info (abfd, plt_list, rel->r_addend))
5712             return FALSE;
5713           break;
5714
5715         case R_PPC64_ADDR14:
5716         case R_PPC64_ADDR14_BRNTAKEN:
5717         case R_PPC64_ADDR14_BRTAKEN:
5718         case R_PPC64_ADDR24:
5719           goto dodyn;
5720
5721         case R_PPC64_TPREL64:
5722           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5723           if (bfd_link_pic (info))
5724             info->flags |= DF_STATIC_TLS;
5725           goto dotlstoc;
5726
5727         case R_PPC64_DTPMOD64:
5728           if (rel + 1 < rel_end
5729               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5730               && rel[1].r_offset == rel->r_offset + 8)
5731             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5732           else
5733             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5734           goto dotlstoc;
5735
5736         case R_PPC64_DTPREL64:
5737           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5738           if (rel != relocs
5739               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5740               && rel[-1].r_offset == rel->r_offset - 8)
5741             /* This is the second reloc of a dtpmod, dtprel pair.
5742                Don't mark with TLS_DTPREL.  */
5743             goto dodyn;
5744
5745         dotlstoc:
5746           sec->has_tls_reloc = 1;
5747           if (h != NULL)
5748             {
5749               struct ppc_link_hash_entry *eh;
5750               eh = (struct ppc_link_hash_entry *) h;
5751               eh->tls_mask |= tls_type;
5752             }
5753           else
5754             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5755                                         rel->r_addend, tls_type))
5756               return FALSE;
5757
5758           ppc64_sec = ppc64_elf_section_data (sec);
5759           if (ppc64_sec->sec_type != sec_toc)
5760             {
5761               bfd_size_type amt;
5762
5763               /* One extra to simplify get_tls_mask.  */
5764               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5765               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5766               if (ppc64_sec->u.toc.symndx == NULL)
5767                 return FALSE;
5768               amt = sec->size * sizeof (bfd_vma) / 8;
5769               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5770               if (ppc64_sec->u.toc.add == NULL)
5771                 return FALSE;
5772               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5773               ppc64_sec->sec_type = sec_toc;
5774             }
5775           BFD_ASSERT (rel->r_offset % 8 == 0);
5776           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5777           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5778
5779           /* Mark the second slot of a GD or LD entry.
5780              -1 to indicate GD and -2 to indicate LD.  */
5781           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5782             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5783           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5784             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5785           goto dodyn;
5786
5787         case R_PPC64_TPREL16:
5788         case R_PPC64_TPREL16_LO:
5789         case R_PPC64_TPREL16_HI:
5790         case R_PPC64_TPREL16_HA:
5791         case R_PPC64_TPREL16_DS:
5792         case R_PPC64_TPREL16_LO_DS:
5793         case R_PPC64_TPREL16_HIGH:
5794         case R_PPC64_TPREL16_HIGHA:
5795         case R_PPC64_TPREL16_HIGHER:
5796         case R_PPC64_TPREL16_HIGHERA:
5797         case R_PPC64_TPREL16_HIGHEST:
5798         case R_PPC64_TPREL16_HIGHESTA:
5799           if (bfd_link_pic (info))
5800             {
5801               info->flags |= DF_STATIC_TLS;
5802               goto dodyn;
5803             }
5804           break;
5805
5806         case R_PPC64_ADDR64:
5807           if (opd_sym_map != NULL
5808               && rel + 1 < rel_end
5809               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5810             {
5811               if (h != NULL)
5812                 {
5813                   if (h->root.root.string[0] == '.'
5814                       && h->root.root.string[1] != 0
5815                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5816                     ;
5817                   else
5818                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5819                 }
5820               else
5821                 {
5822                   asection *s;
5823                   Elf_Internal_Sym *isym;
5824
5825                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5826                                                 abfd, r_symndx);
5827                   if (isym == NULL)
5828                     return FALSE;
5829
5830                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5831                   if (s != NULL && s != sec)
5832                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5833                 }
5834             }
5835           /* Fall through.  */
5836
5837         case R_PPC64_ADDR16:
5838         case R_PPC64_ADDR16_DS:
5839         case R_PPC64_ADDR16_HA:
5840         case R_PPC64_ADDR16_HI:
5841         case R_PPC64_ADDR16_HIGH:
5842         case R_PPC64_ADDR16_HIGHA:
5843         case R_PPC64_ADDR16_HIGHER:
5844         case R_PPC64_ADDR16_HIGHERA:
5845         case R_PPC64_ADDR16_HIGHEST:
5846         case R_PPC64_ADDR16_HIGHESTA:
5847         case R_PPC64_ADDR16_LO:
5848         case R_PPC64_ADDR16_LO_DS:
5849           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5850               && rel->r_addend == 0)
5851             {
5852               /* We may need a .plt entry if this reloc refers to a
5853                  function in a shared lib.  */
5854               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5855                 return FALSE;
5856               h->pointer_equality_needed = 1;
5857             }
5858           /* Fall through.  */
5859
5860         case R_PPC64_REL30:
5861         case R_PPC64_REL32:
5862         case R_PPC64_REL64:
5863         case R_PPC64_ADDR32:
5864         case R_PPC64_UADDR16:
5865         case R_PPC64_UADDR32:
5866         case R_PPC64_UADDR64:
5867         case R_PPC64_TOC:
5868           if (h != NULL && !bfd_link_pic (info))
5869             /* We may need a copy reloc.  */
5870             h->non_got_ref = 1;
5871
5872           /* Don't propagate .opd relocs.  */
5873           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5874             break;
5875
5876           /* If we are creating a shared library, and this is a reloc
5877              against a global symbol, or a non PC relative reloc
5878              against a local symbol, then we need to copy the reloc
5879              into the shared library.  However, if we are linking with
5880              -Bsymbolic, we do not need to copy a reloc against a
5881              global symbol which is defined in an object we are
5882              including in the link (i.e., DEF_REGULAR is set).  At
5883              this point we have not seen all the input files, so it is
5884              possible that DEF_REGULAR is not set now but will be set
5885              later (it is never cleared).  In case of a weak definition,
5886              DEF_REGULAR may be cleared later by a strong definition in
5887              a shared library.  We account for that possibility below by
5888              storing information in the dyn_relocs field of the hash
5889              table entry.  A similar situation occurs when creating
5890              shared libraries and symbol visibility changes render the
5891              symbol local.
5892
5893              If on the other hand, we are creating an executable, we
5894              may need to keep relocations for symbols satisfied by a
5895              dynamic library if we manage to avoid copy relocs for the
5896              symbol.  */
5897         dodyn:
5898           if ((bfd_link_pic (info)
5899                && (must_be_dyn_reloc (info, r_type)
5900                    || (h != NULL
5901                        && (!SYMBOLIC_BIND (info, h)
5902                            || h->root.type == bfd_link_hash_defweak
5903                            || !h->def_regular))))
5904               || (ELIMINATE_COPY_RELOCS
5905                   && !bfd_link_pic (info)
5906                   && h != NULL
5907                   && (h->root.type == bfd_link_hash_defweak
5908                       || !h->def_regular))
5909               || (!bfd_link_pic (info)
5910                   && ifunc != NULL))
5911             {
5912               /* We must copy these reloc types into the output file.
5913                  Create a reloc section in dynobj and make room for
5914                  this reloc.  */
5915               if (sreloc == NULL)
5916                 {
5917                   sreloc = _bfd_elf_make_dynamic_reloc_section
5918                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5919
5920                   if (sreloc == NULL)
5921                     return FALSE;
5922                 }
5923
5924               /* If this is a global symbol, we count the number of
5925                  relocations we need for this symbol.  */
5926               if (h != NULL)
5927                 {
5928                   struct elf_dyn_relocs *p;
5929                   struct elf_dyn_relocs **head;
5930
5931                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5932                   p = *head;
5933                   if (p == NULL || p->sec != sec)
5934                     {
5935                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5936                       if (p == NULL)
5937                         return FALSE;
5938                       p->next = *head;
5939                       *head = p;
5940                       p->sec = sec;
5941                       p->count = 0;
5942                       p->pc_count = 0;
5943                     }
5944                   p->count += 1;
5945                   if (!must_be_dyn_reloc (info, r_type))
5946                     p->pc_count += 1;
5947                 }
5948               else
5949                 {
5950                   /* Track dynamic relocs needed for local syms too.
5951                      We really need local syms available to do this
5952                      easily.  Oh well.  */
5953                   struct ppc_dyn_relocs *p;
5954                   struct ppc_dyn_relocs **head;
5955                   bfd_boolean is_ifunc;
5956                   asection *s;
5957                   void *vpp;
5958                   Elf_Internal_Sym *isym;
5959
5960                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5961                                                 abfd, r_symndx);
5962                   if (isym == NULL)
5963                     return FALSE;
5964
5965                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5966                   if (s == NULL)
5967                     s = sec;
5968
5969                   vpp = &elf_section_data (s)->local_dynrel;
5970                   head = (struct ppc_dyn_relocs **) vpp;
5971                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5972                   p = *head;
5973                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5974                     p = p->next;
5975                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5976                     {
5977                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5978                       if (p == NULL)
5979                         return FALSE;
5980                       p->next = *head;
5981                       *head = p;
5982                       p->sec = sec;
5983                       p->ifunc = is_ifunc;
5984                       p->count = 0;
5985                     }
5986                   p->count += 1;
5987                 }
5988             }
5989           break;
5990
5991         default:
5992           break;
5993         }
5994     }
5995
5996   return TRUE;
5997 }
5998
5999 /* Merge backend specific data from an object file to the output
6000    object file when linking.  */
6001
6002 static bfd_boolean
6003 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6004 {
6005   bfd *obfd = info->output_bfd;
6006   unsigned long iflags, oflags;
6007
6008   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6009     return TRUE;
6010
6011   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6012     return TRUE;
6013
6014   if (!_bfd_generic_verify_endian_match (ibfd, info))
6015     return FALSE;
6016
6017   iflags = elf_elfheader (ibfd)->e_flags;
6018   oflags = elf_elfheader (obfd)->e_flags;
6019
6020   if (iflags & ~EF_PPC64_ABI)
6021     {
6022       _bfd_error_handler
6023         /* xgettext:c-format */
6024         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6025       bfd_set_error (bfd_error_bad_value);
6026       return FALSE;
6027     }
6028   else if (iflags != oflags && iflags != 0)
6029     {
6030       _bfd_error_handler
6031         /* xgettext:c-format */
6032         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6033          ibfd, iflags, oflags);
6034       bfd_set_error (bfd_error_bad_value);
6035       return FALSE;
6036     }
6037
6038   _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6039
6040   /* Merge Tag_compatibility attributes and any common GNU ones.  */
6041   _bfd_elf_merge_object_attributes (ibfd, info);
6042
6043   return TRUE;
6044 }
6045
6046 static bfd_boolean
6047 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6048 {
6049   /* Print normal ELF private data.  */
6050   _bfd_elf_print_private_bfd_data (abfd, ptr);
6051
6052   if (elf_elfheader (abfd)->e_flags != 0)
6053     {
6054       FILE *file = ptr;
6055
6056       fprintf (file, _("private flags = 0x%lx:"),
6057                elf_elfheader (abfd)->e_flags);
6058
6059       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6060         fprintf (file, _(" [abiv%ld]"),
6061                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6062       fputc ('\n', file);
6063     }
6064
6065   return TRUE;
6066 }
6067
6068 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
6069    of the code entry point, and its section, which must be in the same
6070    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
6071
6072 static bfd_vma
6073 opd_entry_value (asection *opd_sec,
6074                  bfd_vma offset,
6075                  asection **code_sec,
6076                  bfd_vma *code_off,
6077                  bfd_boolean in_code_sec)
6078 {
6079   bfd *opd_bfd = opd_sec->owner;
6080   Elf_Internal_Rela *relocs;
6081   Elf_Internal_Rela *lo, *hi, *look;
6082   bfd_vma val;
6083
6084   /* No relocs implies we are linking a --just-symbols object, or looking
6085      at a final linked executable with addr2line or somesuch.  */
6086   if (opd_sec->reloc_count == 0)
6087     {
6088       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6089
6090       if (contents == NULL)
6091         {
6092           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6093             return (bfd_vma) -1;
6094           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6095         }
6096
6097       /* PR 17512: file: 64b9dfbb.  */
6098       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6099         return (bfd_vma) -1;
6100
6101       val = bfd_get_64 (opd_bfd, contents + offset);
6102       if (code_sec != NULL)
6103         {
6104           asection *sec, *likely = NULL;
6105
6106           if (in_code_sec)
6107             {
6108               sec = *code_sec;
6109               if (sec->vma <= val
6110                   && val < sec->vma + sec->size)
6111                 likely = sec;
6112               else
6113                 val = -1;
6114             }
6115           else
6116             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6117               if (sec->vma <= val
6118                   && (sec->flags & SEC_LOAD) != 0
6119                   && (sec->flags & SEC_ALLOC) != 0)
6120                 likely = sec;
6121           if (likely != NULL)
6122             {
6123               *code_sec = likely;
6124               if (code_off != NULL)
6125                 *code_off = val - likely->vma;
6126             }
6127         }
6128       return val;
6129     }
6130
6131   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6132
6133   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6134   if (relocs == NULL)
6135     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6136   /* PR 17512: file: df8e1fd6.  */
6137   if (relocs == NULL)
6138     return (bfd_vma) -1;
6139
6140   /* Go find the opd reloc at the sym address.  */
6141   lo = relocs;
6142   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6143   val = (bfd_vma) -1;
6144   while (lo < hi)
6145     {
6146       look = lo + (hi - lo) / 2;
6147       if (look->r_offset < offset)
6148         lo = look + 1;
6149       else if (look->r_offset > offset)
6150         hi = look;
6151       else
6152         {
6153           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6154
6155           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6156               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6157             {
6158               unsigned long symndx = ELF64_R_SYM (look->r_info);
6159               asection *sec = NULL;
6160
6161               if (symndx >= symtab_hdr->sh_info
6162                   && elf_sym_hashes (opd_bfd) != NULL)
6163                 {
6164                   struct elf_link_hash_entry **sym_hashes;
6165                   struct elf_link_hash_entry *rh;
6166
6167                   sym_hashes = elf_sym_hashes (opd_bfd);
6168                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6169                   if (rh != NULL)
6170                     {
6171                       rh = elf_follow_link (rh);
6172                       if (rh->root.type != bfd_link_hash_defined
6173                           && rh->root.type != bfd_link_hash_defweak)
6174                         break;
6175                       if (rh->root.u.def.section->owner == opd_bfd)
6176                         {
6177                           val = rh->root.u.def.value;
6178                           sec = rh->root.u.def.section;
6179                         }
6180                     }
6181                 }
6182
6183               if (sec == NULL)
6184                 {
6185                   Elf_Internal_Sym *sym;
6186
6187                   if (symndx < symtab_hdr->sh_info)
6188                     {
6189                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6190                       if (sym == NULL)
6191                         {
6192                           size_t symcnt = symtab_hdr->sh_info;
6193                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6194                                                       symcnt, 0,
6195                                                       NULL, NULL, NULL);
6196                           if (sym == NULL)
6197                             break;
6198                           symtab_hdr->contents = (bfd_byte *) sym;
6199                         }
6200                       sym += symndx;
6201                     }
6202                   else
6203                     {
6204                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6205                                                   1, symndx,
6206                                                   NULL, NULL, NULL);
6207                       if (sym == NULL)
6208                         break;
6209                     }
6210                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6211                   if (sec == NULL)
6212                     break;
6213                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6214                   val = sym->st_value;
6215                 }
6216
6217               val += look->r_addend;
6218               if (code_off != NULL)
6219                 *code_off = val;
6220               if (code_sec != NULL)
6221                 {
6222                   if (in_code_sec && *code_sec != sec)
6223                     return -1;
6224                   else
6225                     *code_sec = sec;
6226                 }
6227               if (sec->output_section != NULL)
6228                 val += sec->output_section->vma + sec->output_offset;
6229             }
6230           break;
6231         }
6232     }
6233
6234   return val;
6235 }
6236
6237 /* If the ELF symbol SYM might be a function in SEC, return the
6238    function size and set *CODE_OFF to the function's entry point,
6239    otherwise return zero.  */
6240
6241 static bfd_size_type
6242 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6243                               bfd_vma *code_off)
6244 {
6245   bfd_size_type size;
6246
6247   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6248                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6249     return 0;
6250
6251   size = 0;
6252   if (!(sym->flags & BSF_SYNTHETIC))
6253     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6254
6255   if (strcmp (sym->section->name, ".opd") == 0)
6256     {
6257       struct _opd_sec_data *opd = get_opd_info (sym->section);
6258       bfd_vma symval = sym->value;
6259
6260       if (opd != NULL
6261           && opd->adjust != NULL
6262           && elf_section_data (sym->section)->relocs != NULL)
6263         {
6264           /* opd_entry_value will use cached relocs that have been
6265              adjusted, but with raw symbols.  That means both local
6266              and global symbols need adjusting.  */
6267           long adjust = opd->adjust[OPD_NDX (symval)];
6268           if (adjust == -1)
6269             return 0;
6270           symval += adjust;
6271         }
6272
6273       if (opd_entry_value (sym->section, symval,
6274                            &sec, code_off, TRUE) == (bfd_vma) -1)
6275         return 0;
6276       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6277          symbol.  This size has nothing to do with the code size of the
6278          function, which is what we're supposed to return, but the
6279          code size isn't available without looking up the dot-sym.
6280          However, doing that would be a waste of time particularly
6281          since elf_find_function will look at the dot-sym anyway.
6282          Now, elf_find_function will keep the largest size of any
6283          function sym found at the code address of interest, so return
6284          1 here to avoid it incorrectly caching a larger function size
6285          for a small function.  This does mean we return the wrong
6286          size for a new-ABI function of size 24, but all that does is
6287          disable caching for such functions.  */
6288       if (size == 24)
6289         size = 1;
6290     }
6291   else
6292     {
6293       if (sym->section != sec)
6294         return 0;
6295       *code_off = sym->value;
6296     }
6297   if (size == 0)
6298     size = 1;
6299   return size;
6300 }
6301
6302 /* Return true if symbol is defined in a regular object file.  */
6303
6304 static bfd_boolean
6305 is_static_defined (struct elf_link_hash_entry *h)
6306 {
6307   return ((h->root.type == bfd_link_hash_defined
6308            || h->root.type == bfd_link_hash_defweak)
6309           && h->root.u.def.section != NULL
6310           && h->root.u.def.section->output_section != NULL);
6311 }
6312
6313 /* If FDH is a function descriptor symbol, return the associated code
6314    entry symbol if it is defined.  Return NULL otherwise.  */
6315
6316 static struct ppc_link_hash_entry *
6317 defined_code_entry (struct ppc_link_hash_entry *fdh)
6318 {
6319   if (fdh->is_func_descriptor)
6320     {
6321       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6322       if (fh->elf.root.type == bfd_link_hash_defined
6323           || fh->elf.root.type == bfd_link_hash_defweak)
6324         return fh;
6325     }
6326   return NULL;
6327 }
6328
6329 /* If FH is a function code entry symbol, return the associated
6330    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6331
6332 static struct ppc_link_hash_entry *
6333 defined_func_desc (struct ppc_link_hash_entry *fh)
6334 {
6335   if (fh->oh != NULL
6336       && fh->oh->is_func_descriptor)
6337     {
6338       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6339       if (fdh->elf.root.type == bfd_link_hash_defined
6340           || fdh->elf.root.type == bfd_link_hash_defweak)
6341         return fdh;
6342     }
6343   return NULL;
6344 }
6345
6346 /* Mark all our entry sym sections, both opd and code section.  */
6347
6348 static void
6349 ppc64_elf_gc_keep (struct bfd_link_info *info)
6350 {
6351   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6352   struct bfd_sym_chain *sym;
6353
6354   if (htab == NULL)
6355     return;
6356
6357   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6358     {
6359       struct ppc_link_hash_entry *eh, *fh;
6360       asection *sec;
6361
6362       eh = (struct ppc_link_hash_entry *)
6363         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6364       if (eh == NULL)
6365         continue;
6366       if (eh->elf.root.type != bfd_link_hash_defined
6367           && eh->elf.root.type != bfd_link_hash_defweak)
6368         continue;
6369
6370       fh = defined_code_entry (eh);
6371       if (fh != NULL)
6372         {
6373           sec = fh->elf.root.u.def.section;
6374           sec->flags |= SEC_KEEP;
6375         }
6376       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6377                && opd_entry_value (eh->elf.root.u.def.section,
6378                                    eh->elf.root.u.def.value,
6379                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6380         sec->flags |= SEC_KEEP;
6381
6382       sec = eh->elf.root.u.def.section;
6383       sec->flags |= SEC_KEEP;
6384     }
6385 }
6386
6387 /* Mark sections containing dynamically referenced symbols.  When
6388    building shared libraries, we must assume that any visible symbol is
6389    referenced.  */
6390
6391 static bfd_boolean
6392 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6393 {
6394   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6395   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6396   struct ppc_link_hash_entry *fdh;
6397   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6398
6399   /* Dynamic linking info is on the func descriptor sym.  */
6400   fdh = defined_func_desc (eh);
6401   if (fdh != NULL)
6402     eh = fdh;
6403
6404   if ((eh->elf.root.type == bfd_link_hash_defined
6405        || eh->elf.root.type == bfd_link_hash_defweak)
6406       && (eh->elf.ref_dynamic
6407           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6408               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6409               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6410               && (!bfd_link_executable (info)
6411                   || info->export_dynamic
6412                   || (eh->elf.dynamic
6413                       && d != NULL
6414                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6415               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6416                   || !bfd_hide_sym_by_version (info->version_info,
6417                                                eh->elf.root.root.string)))))
6418     {
6419       asection *code_sec;
6420       struct ppc_link_hash_entry *fh;
6421
6422       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6423
6424       /* Function descriptor syms cause the associated
6425          function code sym section to be marked.  */
6426       fh = defined_code_entry (eh);
6427       if (fh != NULL)
6428         {
6429           code_sec = fh->elf.root.u.def.section;
6430           code_sec->flags |= SEC_KEEP;
6431         }
6432       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6433                && opd_entry_value (eh->elf.root.u.def.section,
6434                                    eh->elf.root.u.def.value,
6435                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6436         code_sec->flags |= SEC_KEEP;
6437     }
6438
6439   return TRUE;
6440 }
6441
6442 /* Return the section that should be marked against GC for a given
6443    relocation.  */
6444
6445 static asection *
6446 ppc64_elf_gc_mark_hook (asection *sec,
6447                         struct bfd_link_info *info,
6448                         Elf_Internal_Rela *rel,
6449                         struct elf_link_hash_entry *h,
6450                         Elf_Internal_Sym *sym)
6451 {
6452   asection *rsec;
6453
6454   /* Syms return NULL if we're marking .opd, so we avoid marking all
6455      function sections, as all functions are referenced in .opd.  */
6456   rsec = NULL;
6457   if (get_opd_info (sec) != NULL)
6458     return rsec;
6459
6460   if (h != NULL)
6461     {
6462       enum elf_ppc64_reloc_type r_type;
6463       struct ppc_link_hash_entry *eh, *fh, *fdh;
6464
6465       r_type = ELF64_R_TYPE (rel->r_info);
6466       switch (r_type)
6467         {
6468         case R_PPC64_GNU_VTINHERIT:
6469         case R_PPC64_GNU_VTENTRY:
6470           break;
6471
6472         default:
6473           switch (h->root.type)
6474             {
6475             case bfd_link_hash_defined:
6476             case bfd_link_hash_defweak:
6477               eh = (struct ppc_link_hash_entry *) h;
6478               fdh = defined_func_desc (eh);
6479               if (fdh != NULL)
6480                 eh = fdh;
6481
6482               /* Function descriptor syms cause the associated
6483                  function code sym section to be marked.  */
6484               fh = defined_code_entry (eh);
6485               if (fh != NULL)
6486                 {
6487                   /* They also mark their opd section.  */
6488                   eh->elf.root.u.def.section->gc_mark = 1;
6489
6490                   rsec = fh->elf.root.u.def.section;
6491                 }
6492               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6493                        && opd_entry_value (eh->elf.root.u.def.section,
6494                                            eh->elf.root.u.def.value,
6495                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6496                 eh->elf.root.u.def.section->gc_mark = 1;
6497               else
6498                 rsec = h->root.u.def.section;
6499               break;
6500
6501             case bfd_link_hash_common:
6502               rsec = h->root.u.c.p->section;
6503               break;
6504
6505             default:
6506               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6507             }
6508         }
6509     }
6510   else
6511     {
6512       struct _opd_sec_data *opd;
6513
6514       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6515       opd = get_opd_info (rsec);
6516       if (opd != NULL && opd->func_sec != NULL)
6517         {
6518           rsec->gc_mark = 1;
6519
6520           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6521         }
6522     }
6523
6524   return rsec;
6525 }
6526
6527 /* Update the .got, .plt. and dynamic reloc reference counts for the
6528    section being removed.  */
6529
6530 static bfd_boolean
6531 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6532                          asection *sec, const Elf_Internal_Rela *relocs)
6533 {
6534   struct ppc_link_hash_table *htab;
6535   Elf_Internal_Shdr *symtab_hdr;
6536   struct elf_link_hash_entry **sym_hashes;
6537   struct got_entry **local_got_ents;
6538   const Elf_Internal_Rela *rel, *relend;
6539
6540   if (bfd_link_relocatable (info))
6541     return TRUE;
6542
6543   if ((sec->flags & SEC_ALLOC) == 0)
6544     return TRUE;
6545
6546   elf_section_data (sec)->local_dynrel = NULL;
6547
6548   htab = ppc_hash_table (info);
6549   if (htab == NULL)
6550     return FALSE;
6551
6552   symtab_hdr = &elf_symtab_hdr (abfd);
6553   sym_hashes = elf_sym_hashes (abfd);
6554   local_got_ents = elf_local_got_ents (abfd);
6555
6556   relend = relocs + sec->reloc_count;
6557   for (rel = relocs; rel < relend; rel++)
6558     {
6559       unsigned long r_symndx;
6560       enum elf_ppc64_reloc_type r_type;
6561       struct elf_link_hash_entry *h = NULL;
6562       struct plt_entry **plt_list;
6563       unsigned char tls_type = 0;
6564
6565       r_symndx = ELF64_R_SYM (rel->r_info);
6566       r_type = ELF64_R_TYPE (rel->r_info);
6567       if (r_symndx >= symtab_hdr->sh_info)
6568         {
6569           struct ppc_link_hash_entry *eh;
6570           struct elf_dyn_relocs **pp;
6571           struct elf_dyn_relocs *p;
6572
6573           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6574           h = elf_follow_link (h);
6575           eh = (struct ppc_link_hash_entry *) h;
6576
6577           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6578             if (p->sec == sec)
6579               {
6580                 /* Everything must go for SEC.  */
6581                 *pp = p->next;
6582                 break;
6583               }
6584         }
6585
6586       switch (r_type)
6587         {
6588         case R_PPC64_GOT_TLSLD16:
6589         case R_PPC64_GOT_TLSLD16_LO:
6590         case R_PPC64_GOT_TLSLD16_HI:
6591         case R_PPC64_GOT_TLSLD16_HA:
6592           tls_type = TLS_TLS | TLS_LD;
6593           goto dogot;
6594
6595         case R_PPC64_GOT_TLSGD16:
6596         case R_PPC64_GOT_TLSGD16_LO:
6597         case R_PPC64_GOT_TLSGD16_HI:
6598         case R_PPC64_GOT_TLSGD16_HA:
6599           tls_type = TLS_TLS | TLS_GD;
6600           goto dogot;
6601
6602         case R_PPC64_GOT_TPREL16_DS:
6603         case R_PPC64_GOT_TPREL16_LO_DS:
6604         case R_PPC64_GOT_TPREL16_HI:
6605         case R_PPC64_GOT_TPREL16_HA:
6606           tls_type = TLS_TLS | TLS_TPREL;
6607           goto dogot;
6608
6609         case R_PPC64_GOT_DTPREL16_DS:
6610         case R_PPC64_GOT_DTPREL16_LO_DS:
6611         case R_PPC64_GOT_DTPREL16_HI:
6612         case R_PPC64_GOT_DTPREL16_HA:
6613           tls_type = TLS_TLS | TLS_DTPREL;
6614           goto dogot;
6615
6616         case R_PPC64_GOT16:
6617         case R_PPC64_GOT16_DS:
6618         case R_PPC64_GOT16_HA:
6619         case R_PPC64_GOT16_HI:
6620         case R_PPC64_GOT16_LO:
6621         case R_PPC64_GOT16_LO_DS:
6622         dogot:
6623           {
6624             struct got_entry *ent;
6625
6626             if (h != NULL)
6627               ent = h->got.glist;
6628             else
6629               ent = local_got_ents[r_symndx];
6630
6631             for (; ent != NULL; ent = ent->next)
6632               if (ent->addend == rel->r_addend
6633                   && ent->owner == abfd
6634                   && ent->tls_type == tls_type)
6635                 break;
6636             if (ent == NULL)
6637               abort ();
6638             if (ent->got.refcount > 0)
6639               ent->got.refcount -= 1;
6640           }
6641           break;
6642
6643         case R_PPC64_PLT16_HA:
6644         case R_PPC64_PLT16_HI:
6645         case R_PPC64_PLT16_LO:
6646         case R_PPC64_PLT32:
6647         case R_PPC64_PLT64:
6648         case R_PPC64_REL14:
6649         case R_PPC64_REL14_BRNTAKEN:
6650         case R_PPC64_REL14_BRTAKEN:
6651         case R_PPC64_REL24:
6652           plt_list = NULL;
6653           if (h != NULL)
6654             plt_list = &h->plt.plist;
6655           else if (local_got_ents != NULL)
6656             {
6657               struct plt_entry **local_plt = (struct plt_entry **)
6658                 (local_got_ents + symtab_hdr->sh_info);
6659               unsigned char *local_got_tls_masks = (unsigned char *)
6660                 (local_plt + symtab_hdr->sh_info);
6661               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6662                 plt_list = local_plt + r_symndx;
6663             }
6664           if (plt_list)
6665             {
6666               struct plt_entry *ent;
6667
6668               for (ent = *plt_list; ent != NULL; ent = ent->next)
6669                 if (ent->addend == rel->r_addend)
6670                   break;
6671               if (ent != NULL && ent->plt.refcount > 0)
6672                 ent->plt.refcount -= 1;
6673             }
6674           break;
6675
6676         default:
6677           break;
6678         }
6679     }
6680   return TRUE;
6681 }
6682
6683 /* The maximum size of .sfpr.  */
6684 #define SFPR_MAX (218*4)
6685
6686 struct sfpr_def_parms
6687 {
6688   const char name[12];
6689   unsigned char lo, hi;
6690   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6691   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6692 };
6693
6694 /* Auto-generate _save*, _rest* functions in .sfpr.
6695    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6696    instead.  */
6697
6698 static bfd_boolean
6699 sfpr_define (struct bfd_link_info *info,
6700              const struct sfpr_def_parms *parm,
6701              asection *stub_sec)
6702 {
6703   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6704   unsigned int i;
6705   size_t len = strlen (parm->name);
6706   bfd_boolean writing = FALSE;
6707   char sym[16];
6708
6709   if (htab == NULL)
6710     return FALSE;
6711
6712   memcpy (sym, parm->name, len);
6713   sym[len + 2] = 0;
6714
6715   for (i = parm->lo; i <= parm->hi; i++)
6716     {
6717       struct ppc_link_hash_entry *h;
6718
6719       sym[len + 0] = i / 10 + '0';
6720       sym[len + 1] = i % 10 + '0';
6721       h = (struct ppc_link_hash_entry *)
6722         elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6723       if (stub_sec != NULL)
6724         {
6725           if (h != NULL
6726               && h->elf.root.type == bfd_link_hash_defined
6727               && h->elf.root.u.def.section == htab->sfpr)
6728             {
6729               struct elf_link_hash_entry *s;
6730               char buf[32];
6731               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6732               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6733               if (s == NULL)
6734                 return FALSE;
6735               if (s->root.type == bfd_link_hash_new
6736                   || (s->root.type = bfd_link_hash_defined
6737                       && s->root.u.def.section == stub_sec))
6738                 {
6739                   s->root.type = bfd_link_hash_defined;
6740                   s->root.u.def.section = stub_sec;
6741                   s->root.u.def.value = (stub_sec->size
6742                                          + h->elf.root.u.def.value);
6743                   s->ref_regular = 1;
6744                   s->def_regular = 1;
6745                   s->ref_regular_nonweak = 1;
6746                   s->forced_local = 1;
6747                   s->non_elf = 0;
6748                   s->root.linker_def = 1;
6749                 }
6750             }
6751           continue;
6752         }
6753       if (h != NULL)
6754         {
6755           h->save_res = 1;
6756           if (!h->elf.def_regular)
6757             {
6758               h->elf.root.type = bfd_link_hash_defined;
6759               h->elf.root.u.def.section = htab->sfpr;
6760               h->elf.root.u.def.value = htab->sfpr->size;
6761               h->elf.type = STT_FUNC;
6762               h->elf.def_regular = 1;
6763               h->elf.non_elf = 0;
6764               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6765               writing = TRUE;
6766               if (htab->sfpr->contents == NULL)
6767                 {
6768                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6769                   if (htab->sfpr->contents == NULL)
6770                     return FALSE;
6771                 }
6772             }
6773         }
6774       if (writing)
6775         {
6776           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6777           if (i != parm->hi)
6778             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6779           else
6780             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6781           htab->sfpr->size = p - htab->sfpr->contents;
6782         }
6783     }
6784
6785   return TRUE;
6786 }
6787
6788 static bfd_byte *
6789 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6790 {
6791   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6792   return p + 4;
6793 }
6794
6795 static bfd_byte *
6796 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6797 {
6798   p = savegpr0 (abfd, p, r);
6799   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6800   p = p + 4;
6801   bfd_put_32 (abfd, BLR, p);
6802   return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6807 {
6808   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6809   return p + 4;
6810 }
6811
6812 static bfd_byte *
6813 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6814 {
6815   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6816   p = p + 4;
6817   p = restgpr0 (abfd, p, r);
6818   bfd_put_32 (abfd, MTLR_R0, p);
6819   p = p + 4;
6820   if (r == 29)
6821     {
6822       p = restgpr0 (abfd, p, 30);
6823       p = restgpr0 (abfd, p, 31);
6824     }
6825   bfd_put_32 (abfd, BLR, p);
6826   return p + 4;
6827 }
6828
6829 static bfd_byte *
6830 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6831 {
6832   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6833   return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6838 {
6839   p = savegpr1 (abfd, p, r);
6840   bfd_put_32 (abfd, BLR, p);
6841   return p + 4;
6842 }
6843
6844 static bfd_byte *
6845 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6846 {
6847   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6848   return p + 4;
6849 }
6850
6851 static bfd_byte *
6852 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6853 {
6854   p = restgpr1 (abfd, p, r);
6855   bfd_put_32 (abfd, BLR, p);
6856   return p + 4;
6857 }
6858
6859 static bfd_byte *
6860 savefpr (bfd *abfd, bfd_byte *p, int r)
6861 {
6862   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6863   return p + 4;
6864 }
6865
6866 static bfd_byte *
6867 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6868 {
6869   p = savefpr (abfd, p, r);
6870   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6871   p = p + 4;
6872   bfd_put_32 (abfd, BLR, p);
6873   return p + 4;
6874 }
6875
6876 static bfd_byte *
6877 restfpr (bfd *abfd, bfd_byte *p, int r)
6878 {
6879   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6880   return p + 4;
6881 }
6882
6883 static bfd_byte *
6884 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6885 {
6886   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6887   p = p + 4;
6888   p = restfpr (abfd, p, r);
6889   bfd_put_32 (abfd, MTLR_R0, p);
6890   p = p + 4;
6891   if (r == 29)
6892     {
6893       p = restfpr (abfd, p, 30);
6894       p = restfpr (abfd, p, 31);
6895     }
6896   bfd_put_32 (abfd, BLR, p);
6897   return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6902 {
6903   p = savefpr (abfd, p, r);
6904   bfd_put_32 (abfd, BLR, p);
6905   return p + 4;
6906 }
6907
6908 static bfd_byte *
6909 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6910 {
6911   p = restfpr (abfd, p, r);
6912   bfd_put_32 (abfd, BLR, p);
6913   return p + 4;
6914 }
6915
6916 static bfd_byte *
6917 savevr (bfd *abfd, bfd_byte *p, int r)
6918 {
6919   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6920   p = p + 4;
6921   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6922   return p + 4;
6923 }
6924
6925 static bfd_byte *
6926 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6927 {
6928   p = savevr (abfd, p, r);
6929   bfd_put_32 (abfd, BLR, p);
6930   return p + 4;
6931 }
6932
6933 static bfd_byte *
6934 restvr (bfd *abfd, bfd_byte *p, int r)
6935 {
6936   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6937   p = p + 4;
6938   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6939   return p + 4;
6940 }
6941
6942 static bfd_byte *
6943 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6944 {
6945   p = restvr (abfd, p, r);
6946   bfd_put_32 (abfd, BLR, p);
6947   return p + 4;
6948 }
6949
6950 /* Called via elf_link_hash_traverse to transfer dynamic linking
6951    information on function code symbol entries to their corresponding
6952    function descriptor symbol entries.  */
6953
6954 static bfd_boolean
6955 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6956 {
6957   struct bfd_link_info *info;
6958   struct ppc_link_hash_table *htab;
6959   struct plt_entry *ent;
6960   struct ppc_link_hash_entry *fh;
6961   struct ppc_link_hash_entry *fdh;
6962   bfd_boolean force_local;
6963
6964   fh = (struct ppc_link_hash_entry *) h;
6965   if (fh->elf.root.type == bfd_link_hash_indirect)
6966     return TRUE;
6967
6968   info = inf;
6969   htab = ppc_hash_table (info);
6970   if (htab == NULL)
6971     return FALSE;
6972
6973   /* Resolve undefined references to dot-symbols as the value
6974      in the function descriptor, if we have one in a regular object.
6975      This is to satisfy cases like ".quad .foo".  Calls to functions
6976      in dynamic objects are handled elsewhere.  */
6977   if (fh->elf.root.type == bfd_link_hash_undefweak
6978       && fh->was_undefined
6979       && (fdh = defined_func_desc (fh)) != NULL
6980       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6981       && opd_entry_value (fdh->elf.root.u.def.section,
6982                           fdh->elf.root.u.def.value,
6983                           &fh->elf.root.u.def.section,
6984                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6985     {
6986       fh->elf.root.type = fdh->elf.root.type;
6987       fh->elf.forced_local = 1;
6988       fh->elf.def_regular = fdh->elf.def_regular;
6989       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6990     }
6991
6992   /* If this is a function code symbol, transfer dynamic linking
6993      information to the function descriptor symbol.  */
6994   if (!fh->is_func)
6995     return TRUE;
6996
6997   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6998     if (ent->plt.refcount > 0)
6999       break;
7000   if (ent == NULL
7001       || fh->elf.root.root.string[0] != '.'
7002       || fh->elf.root.root.string[1] == '\0')
7003     return TRUE;
7004
7005   /* Find the corresponding function descriptor symbol.  Create it
7006      as undefined if necessary.  */
7007
7008   fdh = lookup_fdh (fh, htab);
7009   if (fdh == NULL
7010       && !bfd_link_executable (info)
7011       && (fh->elf.root.type == bfd_link_hash_undefined
7012           || fh->elf.root.type == bfd_link_hash_undefweak))
7013     {
7014       fdh = make_fdh (info, fh);
7015       if (fdh == NULL)
7016         return FALSE;
7017     }
7018
7019   /* Fake function descriptors are made undefweak.  If the function
7020      code symbol is strong undefined, make the fake sym the same.
7021      If the function code symbol is defined, then force the fake
7022      descriptor local;  We can't support overriding of symbols in a
7023      shared library on a fake descriptor.  */
7024
7025   if (fdh != NULL
7026       && fdh->fake
7027       && fdh->elf.root.type == bfd_link_hash_undefweak)
7028     {
7029       if (fh->elf.root.type == bfd_link_hash_undefined)
7030         {
7031           fdh->elf.root.type = bfd_link_hash_undefined;
7032           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7033         }
7034       else if (fh->elf.root.type == bfd_link_hash_defined
7035                || fh->elf.root.type == bfd_link_hash_defweak)
7036         {
7037           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7038         }
7039     }
7040
7041   if (fdh != NULL
7042       && !fdh->elf.forced_local
7043       && (!bfd_link_executable (info)
7044           || fdh->elf.def_dynamic
7045           || fdh->elf.ref_dynamic
7046           || (fdh->elf.root.type == bfd_link_hash_undefweak
7047               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7048     {
7049       if (fdh->elf.dynindx == -1)
7050         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7051           return FALSE;
7052       fdh->elf.ref_regular |= fh->elf.ref_regular;
7053       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7054       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7055       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7056       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7057         {
7058           move_plt_plist (fh, fdh);
7059           fdh->elf.needs_plt = 1;
7060         }
7061       fdh->is_func_descriptor = 1;
7062       fdh->oh = fh;
7063       fh->oh = fdh;
7064     }
7065
7066   /* Now that the info is on the function descriptor, clear the
7067      function code sym info.  Any function code syms for which we
7068      don't have a definition in a regular file, we force local.
7069      This prevents a shared library from exporting syms that have
7070      been imported from another library.  Function code syms that
7071      are really in the library we must leave global to prevent the
7072      linker dragging in a definition from a static library.  */
7073   force_local = (!fh->elf.def_regular
7074                  || fdh == NULL
7075                  || !fdh->elf.def_regular
7076                  || fdh->elf.forced_local);
7077   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7078
7079   return TRUE;
7080 }
7081
7082 static const struct sfpr_def_parms save_res_funcs[] =
7083   {
7084     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7085     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7086     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7087     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7088     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7089     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7090     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7091     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7092     { "._savef", 14, 31, savefpr, savefpr1_tail },
7093     { "._restf", 14, 31, restfpr, restfpr1_tail },
7094     { "_savevr_", 20, 31, savevr, savevr_tail },
7095     { "_restvr_", 20, 31, restvr, restvr_tail }
7096   };
7097
7098 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
7099    this hook to a) provide some gcc support functions, and b) transfer
7100    dynamic linking information gathered so far on function code symbol
7101    entries, to their corresponding function descriptor symbol entries.  */
7102
7103 static bfd_boolean
7104 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7105                             struct bfd_link_info *info)
7106 {
7107   struct ppc_link_hash_table *htab;
7108
7109   htab = ppc_hash_table (info);
7110   if (htab == NULL)
7111     return FALSE;
7112
7113   /* Provide any missing _save* and _rest* functions.  */
7114   if (htab->sfpr != NULL)
7115     {
7116       unsigned int i;
7117
7118       htab->sfpr->size = 0;
7119       for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7120         if (!sfpr_define (info, &save_res_funcs[i], NULL))
7121           return FALSE;
7122       if (htab->sfpr->size == 0)
7123         htab->sfpr->flags |= SEC_EXCLUDE;
7124     }
7125
7126   if (bfd_link_relocatable (info))
7127     return TRUE;
7128
7129   if (htab->elf.hgot != NULL)
7130     {
7131       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7132       /* Make .TOC. defined so as to prevent it being made dynamic.
7133          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7134       if (!htab->elf.hgot->def_regular
7135           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7136         {
7137           htab->elf.hgot->root.type = bfd_link_hash_defined;
7138           htab->elf.hgot->root.u.def.value = 0;
7139           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7140           htab->elf.hgot->def_regular = 1;
7141           htab->elf.hgot->root.linker_def = 1;
7142         }
7143       htab->elf.hgot->type = STT_OBJECT;
7144       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7145                                | STV_HIDDEN);
7146     }
7147
7148   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7149
7150   return TRUE;
7151 }
7152
7153 /* Return true if we have dynamic relocs against H that apply to
7154    read-only sections.  */
7155
7156 static bfd_boolean
7157 readonly_dynrelocs (struct elf_link_hash_entry *h)
7158 {
7159   struct ppc_link_hash_entry *eh;
7160   struct elf_dyn_relocs *p;
7161
7162   eh = (struct ppc_link_hash_entry *) h;
7163   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7164     {
7165       asection *s = p->sec->output_section;
7166
7167       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7168         return TRUE;
7169     }
7170   return FALSE;
7171 }
7172
7173 /* Return true if we have dynamic relocs against H or any of its weak
7174    aliases, that apply to read-only sections.  */
7175
7176 static bfd_boolean
7177 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7178 {
7179   struct ppc_link_hash_entry *eh;
7180
7181   eh = (struct ppc_link_hash_entry *) h;
7182   do
7183     {
7184       if (readonly_dynrelocs (&eh->elf))
7185         return TRUE;
7186       eh = eh->weakref;
7187     } while (eh != NULL && &eh->elf != h);
7188
7189   return FALSE;
7190 }
7191
7192 /* Return whether EH has pc-relative dynamic relocs.  */
7193
7194 static bfd_boolean
7195 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7196 {
7197   struct elf_dyn_relocs *p;
7198
7199   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7200     if (p->pc_count != 0)
7201       return TRUE;
7202   return FALSE;
7203 }
7204
7205 /* Return true if a global entry stub will be created for H.  Valid
7206    for ELFv2 before plt entries have been allocated.  */
7207
7208 static bfd_boolean
7209 global_entry_stub (struct elf_link_hash_entry *h)
7210 {
7211   struct plt_entry *pent;
7212
7213   if (!h->pointer_equality_needed
7214       || h->def_regular)
7215     return FALSE;
7216
7217   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7218     if (pent->plt.refcount > 0
7219         && pent->addend == 0)
7220       return TRUE;
7221
7222   return FALSE;
7223 }
7224
7225 /* Adjust a symbol defined by a dynamic object and referenced by a
7226    regular object.  The current definition is in some section of the
7227    dynamic object, but we're not including those sections.  We have to
7228    change the definition to something the rest of the link can
7229    understand.  */
7230
7231 static bfd_boolean
7232 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7233                                  struct elf_link_hash_entry *h)
7234 {
7235   struct ppc_link_hash_table *htab;
7236   asection *s;
7237
7238   htab = ppc_hash_table (info);
7239   if (htab == NULL)
7240     return FALSE;
7241
7242   /* Deal with function syms.  */
7243   if (h->type == STT_FUNC
7244       || h->type == STT_GNU_IFUNC
7245       || h->needs_plt)
7246     {
7247       /* Clear procedure linkage table information for any symbol that
7248          won't need a .plt entry.  */
7249       struct plt_entry *ent;
7250       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7251         if (ent->plt.refcount > 0)
7252           break;
7253       if (ent == NULL
7254           || (h->type != STT_GNU_IFUNC
7255               && (SYMBOL_CALLS_LOCAL (info, h)
7256                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7257                       && h->root.type == bfd_link_hash_undefweak)))
7258           || ((struct ppc_link_hash_entry *) h)->save_res)
7259         {
7260           h->plt.plist = NULL;
7261           h->needs_plt = 0;
7262           h->pointer_equality_needed = 0;
7263         }
7264       else if (abiversion (info->output_bfd) >= 2)
7265         {
7266           /* Taking a function's address in a read/write section
7267              doesn't require us to define the function symbol in the
7268              executable on a global entry stub.  A dynamic reloc can
7269              be used instead.  The reason we prefer a few more dynamic
7270              relocs is that calling via a global entry stub costs a
7271              few more instructions, and pointer_equality_needed causes
7272              extra work in ld.so when resolving these symbols.  */
7273           if (global_entry_stub (h)
7274               && !alias_readonly_dynrelocs (h))
7275             {
7276               h->pointer_equality_needed = 0;
7277               /* After adjust_dynamic_symbol, non_got_ref set in
7278                  the non-pic case means that dyn_relocs for this
7279                  symbol should be discarded.  */
7280               h->non_got_ref = 0;
7281             }
7282
7283           /* If making a plt entry, then we don't need copy relocs.  */
7284           return TRUE;
7285         }
7286     }
7287   else
7288     h->plt.plist = NULL;
7289
7290   /* If this is a weak symbol, and there is a real definition, the
7291      processor independent code will have arranged for us to see the
7292      real definition first, and we can just use the same value.  */
7293   if (h->u.weakdef != NULL)
7294     {
7295       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7296                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7297       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7298       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7299       if (ELIMINATE_COPY_RELOCS)
7300         h->non_got_ref = h->u.weakdef->non_got_ref;
7301       return TRUE;
7302     }
7303
7304   /* If we are creating a shared library, we must presume that the
7305      only references to the symbol are via the global offset table.
7306      For such cases we need not do anything here; the relocations will
7307      be handled correctly by relocate_section.  */
7308   if (bfd_link_pic (info))
7309     return TRUE;
7310
7311   /* If there are no references to this symbol that do not use the
7312      GOT, we don't need to generate a copy reloc.  */
7313   if (!h->non_got_ref)
7314     return TRUE;
7315
7316   /* Don't generate a copy reloc for symbols defined in the executable.  */
7317   if (!h->def_dynamic || !h->ref_regular || h->def_regular
7318
7319       /* If -z nocopyreloc was given, don't generate them either.  */
7320       || info->nocopyreloc
7321
7322       /* If we didn't find any dynamic relocs in read-only sections, then
7323          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7324       || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7325
7326       /* Protected variables do not work with .dynbss.  The copy in
7327          .dynbss won't be used by the shared library with the protected
7328          definition for the variable.  Text relocations are preferable
7329          to an incorrect program.  */
7330       || h->protected_def)
7331     {
7332       h->non_got_ref = 0;
7333       return TRUE;
7334     }
7335
7336   if (h->plt.plist != NULL)
7337     {
7338       /* We should never get here, but unfortunately there are versions
7339          of gcc out there that improperly (for this ABI) put initialized
7340          function pointers, vtable refs and suchlike in read-only
7341          sections.  Allow them to proceed, but warn that this might
7342          break at runtime.  */
7343       info->callbacks->einfo
7344         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7345            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7346          h->root.root.string);
7347     }
7348
7349   /* This is a reference to a symbol defined by a dynamic object which
7350      is not a function.  */
7351
7352   /* We must allocate the symbol in our .dynbss section, which will
7353      become part of the .bss section of the executable.  There will be
7354      an entry for this symbol in the .dynsym section.  The dynamic
7355      object will contain position independent code, so all references
7356      from the dynamic object to this symbol will go through the global
7357      offset table.  The dynamic linker will use the .dynsym entry to
7358      determine the address it must put in the global offset table, so
7359      both the dynamic object and the regular object will refer to the
7360      same memory location for the variable.  */
7361
7362   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7363      to copy the initial value out of the dynamic object and into the
7364      runtime process image.  We need to remember the offset into the
7365      .rela.bss section we are going to use.  */
7366   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7367     {
7368       htab->relbss->size += sizeof (Elf64_External_Rela);
7369       h->needs_copy = 1;
7370     }
7371
7372   s = htab->dynbss;
7373
7374   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7375 }
7376
7377 /* If given a function descriptor symbol, hide both the function code
7378    sym and the descriptor.  */
7379 static void
7380 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7381                        struct elf_link_hash_entry *h,
7382                        bfd_boolean force_local)
7383 {
7384   struct ppc_link_hash_entry *eh;
7385   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7386
7387   eh = (struct ppc_link_hash_entry *) h;
7388   if (eh->is_func_descriptor)
7389     {
7390       struct ppc_link_hash_entry *fh = eh->oh;
7391
7392       if (fh == NULL)
7393         {
7394           const char *p, *q;
7395           struct elf_link_hash_table *htab = elf_hash_table (info);
7396           char save;
7397
7398           /* We aren't supposed to use alloca in BFD because on
7399              systems which do not have alloca the version in libiberty
7400              calls xmalloc, which might cause the program to crash
7401              when it runs out of memory.  This function doesn't have a
7402              return status, so there's no way to gracefully return an
7403              error.  So cheat.  We know that string[-1] can be safely
7404              accessed;  It's either a string in an ELF string table,
7405              or allocated in an objalloc structure.  */
7406
7407           p = eh->elf.root.root.string - 1;
7408           save = *p;
7409           *(char *) p = '.';
7410           fh = (struct ppc_link_hash_entry *)
7411             elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7412           *(char *) p = save;
7413
7414           /* Unfortunately, if it so happens that the string we were
7415              looking for was allocated immediately before this string,
7416              then we overwrote the string terminator.  That's the only
7417              reason the lookup should fail.  */
7418           if (fh == NULL)
7419             {
7420               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7421               while (q >= eh->elf.root.root.string && *q == *p)
7422                 --q, --p;
7423               if (q < eh->elf.root.root.string && *p == '.')
7424                 fh = (struct ppc_link_hash_entry *)
7425                   elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7426             }
7427           if (fh != NULL)
7428             {
7429               eh->oh = fh;
7430               fh->oh = eh;
7431             }
7432         }
7433       if (fh != NULL)
7434         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7435     }
7436 }
7437
7438 static bfd_boolean
7439 get_sym_h (struct elf_link_hash_entry **hp,
7440            Elf_Internal_Sym **symp,
7441            asection **symsecp,
7442            unsigned char **tls_maskp,
7443            Elf_Internal_Sym **locsymsp,
7444            unsigned long r_symndx,
7445            bfd *ibfd)
7446 {
7447   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7448
7449   if (r_symndx >= symtab_hdr->sh_info)
7450     {
7451       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7452       struct elf_link_hash_entry *h;
7453
7454       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7455       h = elf_follow_link (h);
7456
7457       if (hp != NULL)
7458         *hp = h;
7459
7460       if (symp != NULL)
7461         *symp = NULL;
7462
7463       if (symsecp != NULL)
7464         {
7465           asection *symsec = NULL;
7466           if (h->root.type == bfd_link_hash_defined
7467               || h->root.type == bfd_link_hash_defweak)
7468             symsec = h->root.u.def.section;
7469           *symsecp = symsec;
7470         }
7471
7472       if (tls_maskp != NULL)
7473         {
7474           struct ppc_link_hash_entry *eh;
7475
7476           eh = (struct ppc_link_hash_entry *) h;
7477           *tls_maskp = &eh->tls_mask;
7478         }
7479     }
7480   else
7481     {
7482       Elf_Internal_Sym *sym;
7483       Elf_Internal_Sym *locsyms = *locsymsp;
7484
7485       if (locsyms == NULL)
7486         {
7487           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7488           if (locsyms == NULL)
7489             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7490                                             symtab_hdr->sh_info,
7491                                             0, NULL, NULL, NULL);
7492           if (locsyms == NULL)
7493             return FALSE;
7494           *locsymsp = locsyms;
7495         }
7496       sym = locsyms + r_symndx;
7497
7498       if (hp != NULL)
7499         *hp = NULL;
7500
7501       if (symp != NULL)
7502         *symp = sym;
7503
7504       if (symsecp != NULL)
7505         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7506
7507       if (tls_maskp != NULL)
7508         {
7509           struct got_entry **lgot_ents;
7510           unsigned char *tls_mask;
7511
7512           tls_mask = NULL;
7513           lgot_ents = elf_local_got_ents (ibfd);
7514           if (lgot_ents != NULL)
7515             {
7516               struct plt_entry **local_plt = (struct plt_entry **)
7517                 (lgot_ents + symtab_hdr->sh_info);
7518               unsigned char *lgot_masks = (unsigned char *)
7519                 (local_plt + symtab_hdr->sh_info);
7520               tls_mask = &lgot_masks[r_symndx];
7521             }
7522           *tls_maskp = tls_mask;
7523         }
7524     }
7525   return TRUE;
7526 }
7527
7528 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7529    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7530    type suitable for optimization, and 1 otherwise.  */
7531
7532 static int
7533 get_tls_mask (unsigned char **tls_maskp,
7534               unsigned long *toc_symndx,
7535               bfd_vma *toc_addend,
7536               Elf_Internal_Sym **locsymsp,
7537               const Elf_Internal_Rela *rel,
7538               bfd *ibfd)
7539 {
7540   unsigned long r_symndx;
7541   int next_r;
7542   struct elf_link_hash_entry *h;
7543   Elf_Internal_Sym *sym;
7544   asection *sec;
7545   bfd_vma off;
7546
7547   r_symndx = ELF64_R_SYM (rel->r_info);
7548   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7549     return 0;
7550
7551   if ((*tls_maskp != NULL && **tls_maskp != 0)
7552       || sec == NULL
7553       || ppc64_elf_section_data (sec) == NULL
7554       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7555     return 1;
7556
7557   /* Look inside a TOC section too.  */
7558   if (h != NULL)
7559     {
7560       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7561       off = h->root.u.def.value;
7562     }
7563   else
7564     off = sym->st_value;
7565   off += rel->r_addend;
7566   BFD_ASSERT (off % 8 == 0);
7567   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7568   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7569   if (toc_symndx != NULL)
7570     *toc_symndx = r_symndx;
7571   if (toc_addend != NULL)
7572     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7573   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7574     return 0;
7575   if ((h == NULL || is_static_defined (h))
7576       && (next_r == -1 || next_r == -2))
7577     return 1 - next_r;
7578   return 1;
7579 }
7580
7581 /* Find (or create) an entry in the tocsave hash table.  */
7582
7583 static struct tocsave_entry *
7584 tocsave_find (struct ppc_link_hash_table *htab,
7585               enum insert_option insert,
7586               Elf_Internal_Sym **local_syms,
7587               const Elf_Internal_Rela *irela,
7588               bfd *ibfd)
7589 {
7590   unsigned long r_indx;
7591   struct elf_link_hash_entry *h;
7592   Elf_Internal_Sym *sym;
7593   struct tocsave_entry ent, *p;
7594   hashval_t hash;
7595   struct tocsave_entry **slot;
7596
7597   r_indx = ELF64_R_SYM (irela->r_info);
7598   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7599     return NULL;
7600   if (ent.sec == NULL || ent.sec->output_section == NULL)
7601     {
7602       _bfd_error_handler
7603         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7604       return NULL;
7605     }
7606
7607   if (h != NULL)
7608     ent.offset = h->root.u.def.value;
7609   else
7610     ent.offset = sym->st_value;
7611   ent.offset += irela->r_addend;
7612
7613   hash = tocsave_htab_hash (&ent);
7614   slot = ((struct tocsave_entry **)
7615           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7616   if (slot == NULL)
7617     return NULL;
7618
7619   if (*slot == NULL)
7620     {
7621       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7622       if (p == NULL)
7623         return NULL;
7624       *p = ent;
7625       *slot = p;
7626     }
7627   return *slot;
7628 }
7629
7630 /* Adjust all global syms defined in opd sections.  In gcc generated
7631    code for the old ABI, these will already have been done.  */
7632
7633 static bfd_boolean
7634 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7635 {
7636   struct ppc_link_hash_entry *eh;
7637   asection *sym_sec;
7638   struct _opd_sec_data *opd;
7639
7640   if (h->root.type == bfd_link_hash_indirect)
7641     return TRUE;
7642
7643   if (h->root.type != bfd_link_hash_defined
7644       && h->root.type != bfd_link_hash_defweak)
7645     return TRUE;
7646
7647   eh = (struct ppc_link_hash_entry *) h;
7648   if (eh->adjust_done)
7649     return TRUE;
7650
7651   sym_sec = eh->elf.root.u.def.section;
7652   opd = get_opd_info (sym_sec);
7653   if (opd != NULL && opd->adjust != NULL)
7654     {
7655       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7656       if (adjust == -1)
7657         {
7658           /* This entry has been deleted.  */
7659           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7660           if (dsec == NULL)
7661             {
7662               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7663                 if (discarded_section (dsec))
7664                   {
7665                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7666                     break;
7667                   }
7668             }
7669           eh->elf.root.u.def.value = 0;
7670           eh->elf.root.u.def.section = dsec;
7671         }
7672       else
7673         eh->elf.root.u.def.value += adjust;
7674       eh->adjust_done = 1;
7675     }
7676   return TRUE;
7677 }
7678
7679 /* Handles decrementing dynamic reloc counts for the reloc specified by
7680    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7681    have already been determined.  */
7682
7683 static bfd_boolean
7684 dec_dynrel_count (bfd_vma r_info,
7685                   asection *sec,
7686                   struct bfd_link_info *info,
7687                   Elf_Internal_Sym **local_syms,
7688                   struct elf_link_hash_entry *h,
7689                   Elf_Internal_Sym *sym)
7690 {
7691   enum elf_ppc64_reloc_type r_type;
7692   asection *sym_sec = NULL;
7693
7694   /* Can this reloc be dynamic?  This switch, and later tests here
7695      should be kept in sync with the code in check_relocs.  */
7696   r_type = ELF64_R_TYPE (r_info);
7697   switch (r_type)
7698     {
7699     default:
7700       return TRUE;
7701
7702     case R_PPC64_TPREL16:
7703     case R_PPC64_TPREL16_LO:
7704     case R_PPC64_TPREL16_HI:
7705     case R_PPC64_TPREL16_HA:
7706     case R_PPC64_TPREL16_DS:
7707     case R_PPC64_TPREL16_LO_DS:
7708     case R_PPC64_TPREL16_HIGH:
7709     case R_PPC64_TPREL16_HIGHA:
7710     case R_PPC64_TPREL16_HIGHER:
7711     case R_PPC64_TPREL16_HIGHERA:
7712     case R_PPC64_TPREL16_HIGHEST:
7713     case R_PPC64_TPREL16_HIGHESTA:
7714       if (!bfd_link_pic (info))
7715         return TRUE;
7716
7717     case R_PPC64_TPREL64:
7718     case R_PPC64_DTPMOD64:
7719     case R_PPC64_DTPREL64:
7720     case R_PPC64_ADDR64:
7721     case R_PPC64_REL30:
7722     case R_PPC64_REL32:
7723     case R_PPC64_REL64:
7724     case R_PPC64_ADDR14:
7725     case R_PPC64_ADDR14_BRNTAKEN:
7726     case R_PPC64_ADDR14_BRTAKEN:
7727     case R_PPC64_ADDR16:
7728     case R_PPC64_ADDR16_DS:
7729     case R_PPC64_ADDR16_HA:
7730     case R_PPC64_ADDR16_HI:
7731     case R_PPC64_ADDR16_HIGH:
7732     case R_PPC64_ADDR16_HIGHA:
7733     case R_PPC64_ADDR16_HIGHER:
7734     case R_PPC64_ADDR16_HIGHERA:
7735     case R_PPC64_ADDR16_HIGHEST:
7736     case R_PPC64_ADDR16_HIGHESTA:
7737     case R_PPC64_ADDR16_LO:
7738     case R_PPC64_ADDR16_LO_DS:
7739     case R_PPC64_ADDR24:
7740     case R_PPC64_ADDR32:
7741     case R_PPC64_UADDR16:
7742     case R_PPC64_UADDR32:
7743     case R_PPC64_UADDR64:
7744     case R_PPC64_TOC:
7745       break;
7746     }
7747
7748   if (local_syms != NULL)
7749     {
7750       unsigned long r_symndx;
7751       bfd *ibfd = sec->owner;
7752
7753       r_symndx = ELF64_R_SYM (r_info);
7754       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7755         return FALSE;
7756     }
7757
7758   if ((bfd_link_pic (info)
7759        && (must_be_dyn_reloc (info, r_type)
7760            || (h != NULL
7761                && (!SYMBOLIC_BIND (info, h)
7762                    || h->root.type == bfd_link_hash_defweak
7763                    || !h->def_regular))))
7764       || (ELIMINATE_COPY_RELOCS
7765           && !bfd_link_pic (info)
7766           && h != NULL
7767           && (h->root.type == bfd_link_hash_defweak
7768               || !h->def_regular)))
7769     ;
7770   else
7771     return TRUE;
7772
7773   if (h != NULL)
7774     {
7775       struct elf_dyn_relocs *p;
7776       struct elf_dyn_relocs **pp;
7777       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7778
7779       /* elf_gc_sweep may have already removed all dyn relocs associated
7780          with local syms for a given section.  Also, symbol flags are
7781          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7782          report a dynreloc miscount.  */
7783       if (*pp == NULL && info->gc_sections)
7784         return TRUE;
7785
7786       while ((p = *pp) != NULL)
7787         {
7788           if (p->sec == sec)
7789             {
7790               if (!must_be_dyn_reloc (info, r_type))
7791                 p->pc_count -= 1;
7792               p->count -= 1;
7793               if (p->count == 0)
7794                 *pp = p->next;
7795               return TRUE;
7796             }
7797           pp = &p->next;
7798         }
7799     }
7800   else
7801     {
7802       struct ppc_dyn_relocs *p;
7803       struct ppc_dyn_relocs **pp;
7804       void *vpp;
7805       bfd_boolean is_ifunc;
7806
7807       if (local_syms == NULL)
7808         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7809       if (sym_sec == NULL)
7810         sym_sec = sec;
7811
7812       vpp = &elf_section_data (sym_sec)->local_dynrel;
7813       pp = (struct ppc_dyn_relocs **) vpp;
7814
7815       if (*pp == NULL && info->gc_sections)
7816         return TRUE;
7817
7818       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7819       while ((p = *pp) != NULL)
7820         {
7821           if (p->sec == sec && p->ifunc == is_ifunc)
7822             {
7823               p->count -= 1;
7824               if (p->count == 0)
7825                 *pp = p->next;
7826               return TRUE;
7827             }
7828           pp = &p->next;
7829         }
7830     }
7831
7832   /* xgettext:c-format */
7833   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7834                           sec->owner, sec);
7835   bfd_set_error (bfd_error_bad_value);
7836   return FALSE;
7837 }
7838
7839 /* Remove unused Official Procedure Descriptor entries.  Currently we
7840    only remove those associated with functions in discarded link-once
7841    sections, or weakly defined functions that have been overridden.  It
7842    would be possible to remove many more entries for statically linked
7843    applications.  */
7844
7845 bfd_boolean
7846 ppc64_elf_edit_opd (struct bfd_link_info *info)
7847 {
7848   bfd *ibfd;
7849   bfd_boolean some_edited = FALSE;
7850   asection *need_pad = NULL;
7851   struct ppc_link_hash_table *htab;
7852
7853   htab = ppc_hash_table (info);
7854   if (htab == NULL)
7855     return FALSE;
7856
7857   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7858     {
7859       asection *sec;
7860       Elf_Internal_Rela *relstart, *rel, *relend;
7861       Elf_Internal_Shdr *symtab_hdr;
7862       Elf_Internal_Sym *local_syms;
7863       struct _opd_sec_data *opd;
7864       bfd_boolean need_edit, add_aux_fields, broken;
7865       bfd_size_type cnt_16b = 0;
7866
7867       if (!is_ppc64_elf (ibfd))
7868         continue;
7869
7870       sec = bfd_get_section_by_name (ibfd, ".opd");
7871       if (sec == NULL || sec->size == 0)
7872         continue;
7873
7874       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7875         continue;
7876
7877       if (sec->output_section == bfd_abs_section_ptr)
7878         continue;
7879
7880       /* Look through the section relocs.  */
7881       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7882         continue;
7883
7884       local_syms = NULL;
7885       symtab_hdr = &elf_symtab_hdr (ibfd);
7886
7887       /* Read the relocations.  */
7888       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7889                                             info->keep_memory);
7890       if (relstart == NULL)
7891         return FALSE;
7892
7893       /* First run through the relocs to check they are sane, and to
7894          determine whether we need to edit this opd section.  */
7895       need_edit = FALSE;
7896       broken = FALSE;
7897       need_pad = sec;
7898       relend = relstart + sec->reloc_count;
7899       for (rel = relstart; rel < relend; )
7900         {
7901           enum elf_ppc64_reloc_type r_type;
7902           unsigned long r_symndx;
7903           asection *sym_sec;
7904           struct elf_link_hash_entry *h;
7905           Elf_Internal_Sym *sym;
7906           bfd_vma offset;
7907
7908           /* .opd contains an array of 16 or 24 byte entries.  We're
7909              only interested in the reloc pointing to a function entry
7910              point.  */
7911           offset = rel->r_offset;
7912           if (rel + 1 == relend
7913               || rel[1].r_offset != offset + 8)
7914             {
7915               /* If someone messes with .opd alignment then after a
7916                  "ld -r" we might have padding in the middle of .opd.
7917                  Also, there's nothing to prevent someone putting
7918                  something silly in .opd with the assembler.  No .opd
7919                  optimization for them!  */
7920             broken_opd:
7921               _bfd_error_handler
7922                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7923               broken = TRUE;
7924               break;
7925             }
7926
7927           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7928               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7929             {
7930               _bfd_error_handler
7931                 /* xgettext:c-format */
7932                 (_("%B: unexpected reloc type %u in .opd section"),
7933                  ibfd, r_type);
7934               broken = TRUE;
7935               break;
7936             }
7937
7938           r_symndx = ELF64_R_SYM (rel->r_info);
7939           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7940                           r_symndx, ibfd))
7941             goto error_ret;
7942
7943           if (sym_sec == NULL || sym_sec->owner == NULL)
7944             {
7945               const char *sym_name;
7946               if (h != NULL)
7947                 sym_name = h->root.root.string;
7948               else
7949                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7950                                              sym_sec);
7951
7952               _bfd_error_handler
7953                 /* xgettext:c-format */
7954                 (_("%B: undefined sym `%s' in .opd section"),
7955                  ibfd, sym_name);
7956               broken = TRUE;
7957               break;
7958             }
7959
7960           /* opd entries are always for functions defined in the
7961              current input bfd.  If the symbol isn't defined in the
7962              input bfd, then we won't be using the function in this
7963              bfd;  It must be defined in a linkonce section in another
7964              bfd, or is weak.  It's also possible that we are
7965              discarding the function due to a linker script /DISCARD/,
7966              which we test for via the output_section.  */
7967           if (sym_sec->owner != ibfd
7968               || sym_sec->output_section == bfd_abs_section_ptr)
7969             need_edit = TRUE;
7970
7971           rel += 2;
7972           if (rel + 1 == relend
7973               || (rel + 2 < relend
7974                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7975             ++rel;
7976
7977           if (rel == relend)
7978             {
7979               if (sec->size == offset + 24)
7980                 {
7981                   need_pad = NULL;
7982                   break;
7983                 }
7984               if (sec->size == offset + 16)
7985                 {
7986                   cnt_16b++;
7987                   break;
7988                 }
7989               goto broken_opd;
7990             }
7991           else if (rel + 1 < relend
7992                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7993                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7994             {
7995               if (rel[0].r_offset == offset + 16)
7996                 cnt_16b++;
7997               else if (rel[0].r_offset != offset + 24)
7998                 goto broken_opd;
7999             }
8000           else
8001             goto broken_opd;
8002         }
8003
8004       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8005
8006       if (!broken && (need_edit || add_aux_fields))
8007         {
8008           Elf_Internal_Rela *write_rel;
8009           Elf_Internal_Shdr *rel_hdr;
8010           bfd_byte *rptr, *wptr;
8011           bfd_byte *new_contents;
8012           bfd_size_type amt;
8013
8014           new_contents = NULL;
8015           amt = OPD_NDX (sec->size) * sizeof (long);
8016           opd = &ppc64_elf_section_data (sec)->u.opd;
8017           opd->adjust = bfd_zalloc (sec->owner, amt);
8018           if (opd->adjust == NULL)
8019             return FALSE;
8020           ppc64_elf_section_data (sec)->sec_type = sec_opd;
8021
8022           /* This seems a waste of time as input .opd sections are all
8023              zeros as generated by gcc, but I suppose there's no reason
8024              this will always be so.  We might start putting something in
8025              the third word of .opd entries.  */
8026           if ((sec->flags & SEC_IN_MEMORY) == 0)
8027             {
8028               bfd_byte *loc;
8029               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8030                 {
8031                   if (loc != NULL)
8032                     free (loc);
8033                 error_ret:
8034                   if (local_syms != NULL
8035                       && symtab_hdr->contents != (unsigned char *) local_syms)
8036                     free (local_syms);
8037                   if (elf_section_data (sec)->relocs != relstart)
8038                     free (relstart);
8039                   return FALSE;
8040                 }
8041               sec->contents = loc;
8042               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8043             }
8044
8045           elf_section_data (sec)->relocs = relstart;
8046
8047           new_contents = sec->contents;
8048           if (add_aux_fields)
8049             {
8050               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8051               if (new_contents == NULL)
8052                 return FALSE;
8053               need_pad = NULL;
8054             }
8055           wptr = new_contents;
8056           rptr = sec->contents;
8057           write_rel = relstart;
8058           for (rel = relstart; rel < relend; )
8059             {
8060               unsigned long r_symndx;
8061               asection *sym_sec;
8062               struct elf_link_hash_entry *h;
8063               struct ppc_link_hash_entry *fdh = NULL;
8064               Elf_Internal_Sym *sym;
8065               long opd_ent_size;
8066               Elf_Internal_Rela *next_rel;
8067               bfd_boolean skip;
8068
8069               r_symndx = ELF64_R_SYM (rel->r_info);
8070               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8071                               r_symndx, ibfd))
8072                 goto error_ret;
8073
8074               next_rel = rel + 2;
8075               if (next_rel + 1 == relend
8076                   || (next_rel + 2 < relend
8077                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8078                 ++next_rel;
8079
8080               /* See if the .opd entry is full 24 byte or
8081                  16 byte (with fd_aux entry overlapped with next
8082                  fd_func).  */
8083               opd_ent_size = 24;
8084               if (next_rel == relend)
8085                 {
8086                   if (sec->size == rel->r_offset + 16)
8087                     opd_ent_size = 16;
8088                 }
8089               else if (next_rel->r_offset == rel->r_offset + 16)
8090                 opd_ent_size = 16;
8091
8092               if (h != NULL
8093                   && h->root.root.string[0] == '.')
8094                 {
8095                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8096                   if (fdh != NULL
8097                       && fdh->elf.root.type != bfd_link_hash_defined
8098                       && fdh->elf.root.type != bfd_link_hash_defweak)
8099                     fdh = NULL;
8100                 }
8101
8102               skip = (sym_sec->owner != ibfd
8103                       || sym_sec->output_section == bfd_abs_section_ptr);
8104               if (skip)
8105                 {
8106                   if (fdh != NULL && sym_sec->owner == ibfd)
8107                     {
8108                       /* Arrange for the function descriptor sym
8109                          to be dropped.  */
8110                       fdh->elf.root.u.def.value = 0;
8111                       fdh->elf.root.u.def.section = sym_sec;
8112                     }
8113                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8114
8115                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8116                     rel = next_rel;
8117                   else
8118                     while (1)
8119                       {
8120                         if (!dec_dynrel_count (rel->r_info, sec, info,
8121                                                NULL, h, sym))
8122                           goto error_ret;
8123
8124                         if (++rel == next_rel)
8125                           break;
8126
8127                         r_symndx = ELF64_R_SYM (rel->r_info);
8128                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8129                                         r_symndx, ibfd))
8130                           goto error_ret;
8131                       }
8132                 }
8133               else
8134                 {
8135                   /* We'll be keeping this opd entry.  */
8136                   long adjust;
8137
8138                   if (fdh != NULL)
8139                     {
8140                       /* Redefine the function descriptor symbol to
8141                          this location in the opd section.  It is
8142                          necessary to update the value here rather
8143                          than using an array of adjustments as we do
8144                          for local symbols, because various places
8145                          in the generic ELF code use the value
8146                          stored in u.def.value.  */
8147                       fdh->elf.root.u.def.value = wptr - new_contents;
8148                       fdh->adjust_done = 1;
8149                     }
8150
8151                   /* Local syms are a bit tricky.  We could
8152                      tweak them as they can be cached, but
8153                      we'd need to look through the local syms
8154                      for the function descriptor sym which we
8155                      don't have at the moment.  So keep an
8156                      array of adjustments.  */
8157                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8158                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8159
8160                   if (wptr != rptr)
8161                     memcpy (wptr, rptr, opd_ent_size);
8162                   wptr += opd_ent_size;
8163                   if (add_aux_fields && opd_ent_size == 16)
8164                     {
8165                       memset (wptr, '\0', 8);
8166                       wptr += 8;
8167                     }
8168
8169                   /* We need to adjust any reloc offsets to point to the
8170                      new opd entries.  */
8171                   for ( ; rel != next_rel; ++rel)
8172                     {
8173                       rel->r_offset += adjust;
8174                       if (write_rel != rel)
8175                         memcpy (write_rel, rel, sizeof (*rel));
8176                       ++write_rel;
8177                     }
8178                 }
8179
8180               rptr += opd_ent_size;
8181             }
8182
8183           sec->size = wptr - new_contents;
8184           sec->reloc_count = write_rel - relstart;
8185           if (add_aux_fields)
8186             {
8187               free (sec->contents);
8188               sec->contents = new_contents;
8189             }
8190
8191           /* Fudge the header size too, as this is used later in
8192              elf_bfd_final_link if we are emitting relocs.  */
8193           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8194           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8195           some_edited = TRUE;
8196         }
8197       else if (elf_section_data (sec)->relocs != relstart)
8198         free (relstart);
8199
8200       if (local_syms != NULL
8201           && symtab_hdr->contents != (unsigned char *) local_syms)
8202         {
8203           if (!info->keep_memory)
8204             free (local_syms);
8205           else
8206             symtab_hdr->contents = (unsigned char *) local_syms;
8207         }
8208     }
8209
8210   if (some_edited)
8211     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8212
8213   /* If we are doing a final link and the last .opd entry is just 16 byte
8214      long, add a 8 byte padding after it.  */
8215   if (need_pad != NULL && !bfd_link_relocatable (info))
8216     {
8217       bfd_byte *p;
8218
8219       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8220         {
8221           BFD_ASSERT (need_pad->size > 0);
8222
8223           p = bfd_malloc (need_pad->size + 8);
8224           if (p == NULL)
8225             return FALSE;
8226
8227           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8228                                           p, 0, need_pad->size))
8229             return FALSE;
8230
8231           need_pad->contents = p;
8232           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8233         }
8234       else
8235         {
8236           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8237           if (p == NULL)
8238             return FALSE;
8239
8240           need_pad->contents = p;
8241         }
8242
8243       memset (need_pad->contents + need_pad->size, 0, 8);
8244       need_pad->size += 8;
8245     }
8246
8247   return TRUE;
8248 }
8249
8250 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8251
8252 asection *
8253 ppc64_elf_tls_setup (struct bfd_link_info *info)
8254 {
8255   struct ppc_link_hash_table *htab;
8256
8257   htab = ppc_hash_table (info);
8258   if (htab == NULL)
8259     return NULL;
8260
8261   if (abiversion (info->output_bfd) == 1)
8262     htab->opd_abi = 1;
8263
8264   if (htab->params->no_multi_toc)
8265     htab->do_multi_toc = 0;
8266   else if (!htab->do_multi_toc)
8267     htab->params->no_multi_toc = 1;
8268
8269   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8270                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8271                                               FALSE, FALSE, TRUE));
8272   /* Move dynamic linking info to the function descriptor sym.  */
8273   if (htab->tls_get_addr != NULL)
8274     func_desc_adjust (&htab->tls_get_addr->elf, info);
8275   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8276                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8277                                                  FALSE, FALSE, TRUE));
8278   if (htab->params->tls_get_addr_opt)
8279     {
8280       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8281
8282       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8283                                   FALSE, FALSE, TRUE);
8284       if (opt != NULL)
8285         func_desc_adjust (opt, info);
8286       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8287                                      FALSE, FALSE, TRUE);
8288       if (opt_fd != NULL
8289           && (opt_fd->root.type == bfd_link_hash_defined
8290               || opt_fd->root.type == bfd_link_hash_defweak))
8291         {
8292           /* If glibc supports an optimized __tls_get_addr call stub,
8293              signalled by the presence of __tls_get_addr_opt, and we'll
8294              be calling __tls_get_addr via a plt call stub, then
8295              make __tls_get_addr point to __tls_get_addr_opt.  */
8296           tga_fd = &htab->tls_get_addr_fd->elf;
8297           if (htab->elf.dynamic_sections_created
8298               && tga_fd != NULL
8299               && (tga_fd->type == STT_FUNC
8300                   || tga_fd->needs_plt)
8301               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8302                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8303                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8304             {
8305               struct plt_entry *ent;
8306
8307               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8308                 if (ent->plt.refcount > 0)
8309                   break;
8310               if (ent != NULL)
8311                 {
8312                   tga_fd->root.type = bfd_link_hash_indirect;
8313                   tga_fd->root.u.i.link = &opt_fd->root;
8314                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8315                   opt_fd->forced_local = 0;
8316                   if (opt_fd->dynindx != -1)
8317                     {
8318                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8319                       opt_fd->dynindx = -1;
8320                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8321                                               opt_fd->dynstr_index);
8322                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8323                         return NULL;
8324                     }
8325                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8326                   tga = &htab->tls_get_addr->elf;
8327                   if (opt != NULL && tga != NULL)
8328                     {
8329                       tga->root.type = bfd_link_hash_indirect;
8330                       tga->root.u.i.link = &opt->root;
8331                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8332                       opt->forced_local = 0;
8333                       _bfd_elf_link_hash_hide_symbol (info, opt,
8334                                                       tga->forced_local);
8335                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8336                     }
8337                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8338                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8339                   if (htab->tls_get_addr != NULL)
8340                     {
8341                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8342                       htab->tls_get_addr->is_func = 1;
8343                     }
8344                 }
8345             }
8346         }
8347       else if (htab->params->tls_get_addr_opt < 0)
8348         htab->params->tls_get_addr_opt = 0;
8349     }
8350   return _bfd_elf_tls_setup (info->output_bfd, info);
8351 }
8352
8353 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8354    HASH1 or HASH2.  */
8355
8356 static bfd_boolean
8357 branch_reloc_hash_match (const bfd *ibfd,
8358                          const Elf_Internal_Rela *rel,
8359                          const struct ppc_link_hash_entry *hash1,
8360                          const struct ppc_link_hash_entry *hash2)
8361 {
8362   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8363   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8364   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8365
8366   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8367     {
8368       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8369       struct elf_link_hash_entry *h;
8370
8371       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8372       h = elf_follow_link (h);
8373       if (h == &hash1->elf || h == &hash2->elf)
8374         return TRUE;
8375     }
8376   return FALSE;
8377 }
8378
8379 /* Run through all the TLS relocs looking for optimization
8380    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8381    a preliminary section layout so that we know the TLS segment
8382    offsets.  We can't optimize earlier because some optimizations need
8383    to know the tp offset, and we need to optimize before allocating
8384    dynamic relocations.  */
8385
8386 bfd_boolean
8387 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8388 {
8389   bfd *ibfd;
8390   asection *sec;
8391   struct ppc_link_hash_table *htab;
8392   unsigned char *toc_ref;
8393   int pass;
8394
8395   if (!bfd_link_executable (info))
8396     return TRUE;
8397
8398   htab = ppc_hash_table (info);
8399   if (htab == NULL)
8400     return FALSE;
8401
8402   /* Make two passes over the relocs.  On the first pass, mark toc
8403      entries involved with tls relocs, and check that tls relocs
8404      involved in setting up a tls_get_addr call are indeed followed by
8405      such a call.  If they are not, we can't do any tls optimization.
8406      On the second pass twiddle tls_mask flags to notify
8407      relocate_section that optimization can be done, and adjust got
8408      and plt refcounts.  */
8409   toc_ref = NULL;
8410   for (pass = 0; pass < 2; ++pass)
8411     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8412       {
8413         Elf_Internal_Sym *locsyms = NULL;
8414         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8415
8416         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8417           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8418             {
8419               Elf_Internal_Rela *relstart, *rel, *relend;
8420               bfd_boolean found_tls_get_addr_arg = 0;
8421
8422               /* Read the relocations.  */
8423               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8424                                                     info->keep_memory);
8425               if (relstart == NULL)
8426                 {
8427                   free (toc_ref);
8428                   return FALSE;
8429                 }
8430
8431               relend = relstart + sec->reloc_count;
8432               for (rel = relstart; rel < relend; rel++)
8433                 {
8434                   enum elf_ppc64_reloc_type r_type;
8435                   unsigned long r_symndx;
8436                   struct elf_link_hash_entry *h;
8437                   Elf_Internal_Sym *sym;
8438                   asection *sym_sec;
8439                   unsigned char *tls_mask;
8440                   unsigned char tls_set, tls_clear, tls_type = 0;
8441                   bfd_vma value;
8442                   bfd_boolean ok_tprel, is_local;
8443                   long toc_ref_index = 0;
8444                   int expecting_tls_get_addr = 0;
8445                   bfd_boolean ret = FALSE;
8446
8447                   r_symndx = ELF64_R_SYM (rel->r_info);
8448                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8449                                   r_symndx, ibfd))
8450                     {
8451                     err_free_rel:
8452                       if (elf_section_data (sec)->relocs != relstart)
8453                         free (relstart);
8454                       if (toc_ref != NULL)
8455                         free (toc_ref);
8456                       if (locsyms != NULL
8457                           && (elf_symtab_hdr (ibfd).contents
8458                               != (unsigned char *) locsyms))
8459                         free (locsyms);
8460                       return ret;
8461                     }
8462
8463                   if (h != NULL)
8464                     {
8465                       if (h->root.type == bfd_link_hash_defined
8466                           || h->root.type == bfd_link_hash_defweak)
8467                         value = h->root.u.def.value;
8468                       else if (h->root.type == bfd_link_hash_undefweak)
8469                         value = 0;
8470                       else
8471                         {
8472                           found_tls_get_addr_arg = 0;
8473                           continue;
8474                         }
8475                     }
8476                   else
8477                     /* Symbols referenced by TLS relocs must be of type
8478                        STT_TLS.  So no need for .opd local sym adjust.  */
8479                     value = sym->st_value;
8480
8481                   ok_tprel = FALSE;
8482                   is_local = FALSE;
8483                   if (h == NULL
8484                       || !h->def_dynamic)
8485                     {
8486                       is_local = TRUE;
8487                       if (h != NULL
8488                           && h->root.type == bfd_link_hash_undefweak)
8489                         ok_tprel = TRUE;
8490                       else if (sym_sec != NULL
8491                                && sym_sec->output_section != NULL)
8492                         {
8493                           value += sym_sec->output_offset;
8494                           value += sym_sec->output_section->vma;
8495                           value -= htab->elf.tls_sec->vma;
8496                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8497                                       < (bfd_vma) 1 << 32);
8498                         }
8499                     }
8500
8501                   r_type = ELF64_R_TYPE (rel->r_info);
8502                   /* If this section has old-style __tls_get_addr calls
8503                      without marker relocs, then check that each
8504                      __tls_get_addr call reloc is preceded by a reloc
8505                      that conceivably belongs to the __tls_get_addr arg
8506                      setup insn.  If we don't find matching arg setup
8507                      relocs, don't do any tls optimization.  */
8508                   if (pass == 0
8509                       && sec->has_tls_get_addr_call
8510                       && h != NULL
8511                       && (h == &htab->tls_get_addr->elf
8512                           || h == &htab->tls_get_addr_fd->elf)
8513                       && !found_tls_get_addr_arg
8514                       && is_branch_reloc (r_type))
8515                     {
8516                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8517                                                 "TLS optimization disabled\n"),
8518                                               ibfd, sec, rel->r_offset);
8519                       ret = TRUE;
8520                       goto err_free_rel;
8521                     }
8522
8523                   found_tls_get_addr_arg = 0;
8524                   switch (r_type)
8525                     {
8526                     case R_PPC64_GOT_TLSLD16:
8527                     case R_PPC64_GOT_TLSLD16_LO:
8528                       expecting_tls_get_addr = 1;
8529                       found_tls_get_addr_arg = 1;
8530                       /* Fall through.  */
8531
8532                     case R_PPC64_GOT_TLSLD16_HI:
8533                     case R_PPC64_GOT_TLSLD16_HA:
8534                       /* These relocs should never be against a symbol
8535                          defined in a shared lib.  Leave them alone if
8536                          that turns out to be the case.  */
8537                       if (!is_local)
8538                         continue;
8539
8540                       /* LD -> LE */
8541                       tls_set = 0;
8542                       tls_clear = TLS_LD;
8543                       tls_type = TLS_TLS | TLS_LD;
8544                       break;
8545
8546                     case R_PPC64_GOT_TLSGD16:
8547                     case R_PPC64_GOT_TLSGD16_LO:
8548                       expecting_tls_get_addr = 1;
8549                       found_tls_get_addr_arg = 1;
8550                       /* Fall through. */
8551
8552                     case R_PPC64_GOT_TLSGD16_HI:
8553                     case R_PPC64_GOT_TLSGD16_HA:
8554                       if (ok_tprel)
8555                         /* GD -> LE */
8556                         tls_set = 0;
8557                       else
8558                         /* GD -> IE */
8559                         tls_set = TLS_TLS | TLS_TPRELGD;
8560                       tls_clear = TLS_GD;
8561                       tls_type = TLS_TLS | TLS_GD;
8562                       break;
8563
8564                     case R_PPC64_GOT_TPREL16_DS:
8565                     case R_PPC64_GOT_TPREL16_LO_DS:
8566                     case R_PPC64_GOT_TPREL16_HI:
8567                     case R_PPC64_GOT_TPREL16_HA:
8568                       if (ok_tprel)
8569                         {
8570                           /* IE -> LE */
8571                           tls_set = 0;
8572                           tls_clear = TLS_TPREL;
8573                           tls_type = TLS_TLS | TLS_TPREL;
8574                           break;
8575                         }
8576                       continue;
8577
8578                     case R_PPC64_TLSGD:
8579                     case R_PPC64_TLSLD:
8580                       found_tls_get_addr_arg = 1;
8581                       /* Fall through.  */
8582
8583                     case R_PPC64_TLS:
8584                     case R_PPC64_TOC16:
8585                     case R_PPC64_TOC16_LO:
8586                       if (sym_sec == NULL || sym_sec != toc)
8587                         continue;
8588
8589                       /* Mark this toc entry as referenced by a TLS
8590                          code sequence.  We can do that now in the
8591                          case of R_PPC64_TLS, and after checking for
8592                          tls_get_addr for the TOC16 relocs.  */
8593                       if (toc_ref == NULL)
8594                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8595                       if (toc_ref == NULL)
8596                         goto err_free_rel;
8597
8598                       if (h != NULL)
8599                         value = h->root.u.def.value;
8600                       else
8601                         value = sym->st_value;
8602                       value += rel->r_addend;
8603                       if (value % 8 != 0)
8604                         continue;
8605                       BFD_ASSERT (value < toc->size
8606                                   && toc->output_offset % 8 == 0);
8607                       toc_ref_index = (value + toc->output_offset) / 8;
8608                       if (r_type == R_PPC64_TLS
8609                           || r_type == R_PPC64_TLSGD
8610                           || r_type == R_PPC64_TLSLD)
8611                         {
8612                           toc_ref[toc_ref_index] = 1;
8613                           continue;
8614                         }
8615
8616                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8617                         continue;
8618
8619                       tls_set = 0;
8620                       tls_clear = 0;
8621                       expecting_tls_get_addr = 2;
8622                       break;
8623
8624                     case R_PPC64_TPREL64:
8625                       if (pass == 0
8626                           || sec != toc
8627                           || toc_ref == NULL
8628                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8629                         continue;
8630                       if (ok_tprel)
8631                         {
8632                           /* IE -> LE */
8633                           tls_set = TLS_EXPLICIT;
8634                           tls_clear = TLS_TPREL;
8635                           break;
8636                         }
8637                       continue;
8638
8639                     case R_PPC64_DTPMOD64:
8640                       if (pass == 0
8641                           || sec != toc
8642                           || toc_ref == NULL
8643                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8644                         continue;
8645                       if (rel + 1 < relend
8646                           && (rel[1].r_info
8647                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8648                           && rel[1].r_offset == rel->r_offset + 8)
8649                         {
8650                           if (ok_tprel)
8651                             /* GD -> LE */
8652                             tls_set = TLS_EXPLICIT | TLS_GD;
8653                           else
8654                             /* GD -> IE */
8655                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8656                           tls_clear = TLS_GD;
8657                         }
8658                       else
8659                         {
8660                           if (!is_local)
8661                             continue;
8662
8663                           /* LD -> LE */
8664                           tls_set = TLS_EXPLICIT;
8665                           tls_clear = TLS_LD;
8666                         }
8667                       break;
8668
8669                     default:
8670                       continue;
8671                     }
8672
8673                   if (pass == 0)
8674                     {
8675                       if (!expecting_tls_get_addr
8676                           || !sec->has_tls_get_addr_call)
8677                         continue;
8678
8679                       if (rel + 1 < relend
8680                           && branch_reloc_hash_match (ibfd, rel + 1,
8681                                                       htab->tls_get_addr,
8682                                                       htab->tls_get_addr_fd))
8683                         {
8684                           if (expecting_tls_get_addr == 2)
8685                             {
8686                               /* Check for toc tls entries.  */
8687                               unsigned char *toc_tls;
8688                               int retval;
8689
8690                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8691                                                      &locsyms,
8692                                                      rel, ibfd);
8693                               if (retval == 0)
8694                                 goto err_free_rel;
8695                               if (toc_tls != NULL)
8696                                 {
8697                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8698                                     found_tls_get_addr_arg = 1;
8699                                   if (retval > 1)
8700                                     toc_ref[toc_ref_index] = 1;
8701                                 }
8702                             }
8703                           continue;
8704                         }
8705
8706                       if (expecting_tls_get_addr != 1)
8707                         continue;
8708
8709                       /* Uh oh, we didn't find the expected call.  We
8710                          could just mark this symbol to exclude it
8711                          from tls optimization but it's safer to skip
8712                          the entire optimization.  */
8713                       /* xgettext:c-format */
8714                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8715                                                 "TLS optimization disabled\n"),
8716                                               ibfd, sec, rel->r_offset);
8717                       ret = TRUE;
8718                       goto err_free_rel;
8719                     }
8720
8721                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8722                     {
8723                       struct plt_entry *ent;
8724                       for (ent = htab->tls_get_addr->elf.plt.plist;
8725                            ent != NULL;
8726                            ent = ent->next)
8727                         if (ent->addend == 0)
8728                           {
8729                             if (ent->plt.refcount > 0)
8730                               {
8731                                 ent->plt.refcount -= 1;
8732                                 expecting_tls_get_addr = 0;
8733                               }
8734                             break;
8735                           }
8736                     }
8737
8738                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8739                     {
8740                       struct plt_entry *ent;
8741                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8742                            ent != NULL;
8743                            ent = ent->next)
8744                         if (ent->addend == 0)
8745                           {
8746                             if (ent->plt.refcount > 0)
8747                               ent->plt.refcount -= 1;
8748                             break;
8749                           }
8750                     }
8751
8752                   if (tls_clear == 0)
8753                     continue;
8754
8755                   if ((tls_set & TLS_EXPLICIT) == 0)
8756                     {
8757                       struct got_entry *ent;
8758
8759                       /* Adjust got entry for this reloc.  */
8760                       if (h != NULL)
8761                         ent = h->got.glist;
8762                       else
8763                         ent = elf_local_got_ents (ibfd)[r_symndx];
8764
8765                       for (; ent != NULL; ent = ent->next)
8766                         if (ent->addend == rel->r_addend
8767                             && ent->owner == ibfd
8768                             && ent->tls_type == tls_type)
8769                           break;
8770                       if (ent == NULL)
8771                         abort ();
8772
8773                       if (tls_set == 0)
8774                         {
8775                           /* We managed to get rid of a got entry.  */
8776                           if (ent->got.refcount > 0)
8777                             ent->got.refcount -= 1;
8778                         }
8779                     }
8780                   else
8781                     {
8782                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8783                          we'll lose one or two dyn relocs.  */
8784                       if (!dec_dynrel_count (rel->r_info, sec, info,
8785                                              NULL, h, sym))
8786                         return FALSE;
8787
8788                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8789                         {
8790                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8791                                                  NULL, h, sym))
8792                             return FALSE;
8793                         }
8794                     }
8795
8796                   *tls_mask |= tls_set;
8797                   *tls_mask &= ~tls_clear;
8798                 }
8799
8800               if (elf_section_data (sec)->relocs != relstart)
8801                 free (relstart);
8802             }
8803
8804         if (locsyms != NULL
8805             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8806           {
8807             if (!info->keep_memory)
8808               free (locsyms);
8809             else
8810               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8811           }
8812       }
8813
8814   if (toc_ref != NULL)
8815     free (toc_ref);
8816   return TRUE;
8817 }
8818
8819 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8820    the values of any global symbols in a toc section that has been
8821    edited.  Globals in toc sections should be a rarity, so this function
8822    sets a flag if any are found in toc sections other than the one just
8823    edited, so that futher hash table traversals can be avoided.  */
8824
8825 struct adjust_toc_info
8826 {
8827   asection *toc;
8828   unsigned long *skip;
8829   bfd_boolean global_toc_syms;
8830 };
8831
8832 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8833
8834 static bfd_boolean
8835 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8836 {
8837   struct ppc_link_hash_entry *eh;
8838   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8839   unsigned long i;
8840
8841   if (h->root.type != bfd_link_hash_defined
8842       && h->root.type != bfd_link_hash_defweak)
8843     return TRUE;
8844
8845   eh = (struct ppc_link_hash_entry *) h;
8846   if (eh->adjust_done)
8847     return TRUE;
8848
8849   if (eh->elf.root.u.def.section == toc_inf->toc)
8850     {
8851       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8852         i = toc_inf->toc->rawsize >> 3;
8853       else
8854         i = eh->elf.root.u.def.value >> 3;
8855
8856       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8857         {
8858           _bfd_error_handler
8859             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8860           do
8861             ++i;
8862           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8863           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8864         }
8865
8866       eh->elf.root.u.def.value -= toc_inf->skip[i];
8867       eh->adjust_done = 1;
8868     }
8869   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8870     toc_inf->global_toc_syms = TRUE;
8871
8872   return TRUE;
8873 }
8874
8875 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8876
8877 static bfd_boolean
8878 ok_lo_toc_insn (unsigned int insn)
8879 {
8880   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8881           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8882           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8883           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8884           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8885           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8886           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8887           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8888           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8889           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8890           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8891           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8892           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8893           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8894           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8895               && (insn & 3) != 1)
8896           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8897               && ((insn & 3) == 0 || (insn & 3) == 3))
8898           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8899 }
8900
8901 /* Examine all relocs referencing .toc sections in order to remove
8902    unused .toc entries.  */
8903
8904 bfd_boolean
8905 ppc64_elf_edit_toc (struct bfd_link_info *info)
8906 {
8907   bfd *ibfd;
8908   struct adjust_toc_info toc_inf;
8909   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8910
8911   htab->do_toc_opt = 1;
8912   toc_inf.global_toc_syms = TRUE;
8913   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8914     {
8915       asection *toc, *sec;
8916       Elf_Internal_Shdr *symtab_hdr;
8917       Elf_Internal_Sym *local_syms;
8918       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8919       unsigned long *skip, *drop;
8920       unsigned char *used;
8921       unsigned char *keep, last, some_unused;
8922
8923       if (!is_ppc64_elf (ibfd))
8924         continue;
8925
8926       toc = bfd_get_section_by_name (ibfd, ".toc");
8927       if (toc == NULL
8928           || toc->size == 0
8929           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8930           || discarded_section (toc))
8931         continue;
8932
8933       toc_relocs = NULL;
8934       local_syms = NULL;
8935       symtab_hdr = &elf_symtab_hdr (ibfd);
8936
8937       /* Look at sections dropped from the final link.  */
8938       skip = NULL;
8939       relstart = NULL;
8940       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8941         {
8942           if (sec->reloc_count == 0
8943               || !discarded_section (sec)
8944               || get_opd_info (sec)
8945               || (sec->flags & SEC_ALLOC) == 0
8946               || (sec->flags & SEC_DEBUGGING) != 0)
8947             continue;
8948
8949           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8950           if (relstart == NULL)
8951             goto error_ret;
8952
8953           /* Run through the relocs to see which toc entries might be
8954              unused.  */
8955           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8956             {
8957               enum elf_ppc64_reloc_type r_type;
8958               unsigned long r_symndx;
8959               asection *sym_sec;
8960               struct elf_link_hash_entry *h;
8961               Elf_Internal_Sym *sym;
8962               bfd_vma val;
8963
8964               r_type = ELF64_R_TYPE (rel->r_info);
8965               switch (r_type)
8966                 {
8967                 default:
8968                   continue;
8969
8970                 case R_PPC64_TOC16:
8971                 case R_PPC64_TOC16_LO:
8972                 case R_PPC64_TOC16_HI:
8973                 case R_PPC64_TOC16_HA:
8974                 case R_PPC64_TOC16_DS:
8975                 case R_PPC64_TOC16_LO_DS:
8976                   break;
8977                 }
8978
8979               r_symndx = ELF64_R_SYM (rel->r_info);
8980               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8981                               r_symndx, ibfd))
8982                 goto error_ret;
8983
8984               if (sym_sec != toc)
8985                 continue;
8986
8987               if (h != NULL)
8988                 val = h->root.u.def.value;
8989               else
8990                 val = sym->st_value;
8991               val += rel->r_addend;
8992
8993               if (val >= toc->size)
8994                 continue;
8995
8996               /* Anything in the toc ought to be aligned to 8 bytes.
8997                  If not, don't mark as unused.  */
8998               if (val & 7)
8999                 continue;
9000
9001               if (skip == NULL)
9002                 {
9003                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9004                   if (skip == NULL)
9005                     goto error_ret;
9006                 }
9007
9008               skip[val >> 3] = ref_from_discarded;
9009             }
9010
9011           if (elf_section_data (sec)->relocs != relstart)
9012             free (relstart);
9013         }
9014
9015       /* For largetoc loads of address constants, we can convert
9016          .  addis rx,2,addr@got@ha
9017          .  ld ry,addr@got@l(rx)
9018          to
9019          .  addis rx,2,addr@toc@ha
9020          .  addi ry,rx,addr@toc@l
9021          when addr is within 2G of the toc pointer.  This then means
9022          that the word storing "addr" in the toc is no longer needed.  */
9023
9024       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9025           && toc->output_section->rawsize < (bfd_vma) 1 << 31
9026           && toc->reloc_count != 0)
9027         {
9028           /* Read toc relocs.  */
9029           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9030                                                   info->keep_memory);
9031           if (toc_relocs == NULL)
9032             goto error_ret;
9033
9034           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9035             {
9036               enum elf_ppc64_reloc_type r_type;
9037               unsigned long r_symndx;
9038               asection *sym_sec;
9039               struct elf_link_hash_entry *h;
9040               Elf_Internal_Sym *sym;
9041               bfd_vma val, addr;
9042
9043               r_type = ELF64_R_TYPE (rel->r_info);
9044               if (r_type != R_PPC64_ADDR64)
9045                 continue;
9046
9047               r_symndx = ELF64_R_SYM (rel->r_info);
9048               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9049                               r_symndx, ibfd))
9050                 goto error_ret;
9051
9052               if (sym_sec == NULL
9053                   || sym_sec->output_section == NULL
9054                   || discarded_section (sym_sec))
9055                 continue;
9056
9057               if (!SYMBOL_REFERENCES_LOCAL (info, h))
9058                 continue;
9059
9060               if (h != NULL)
9061                 {
9062                   if (h->type == STT_GNU_IFUNC)
9063                     continue;
9064                   val = h->root.u.def.value;
9065                 }
9066               else
9067                 {
9068                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9069                     continue;
9070                   val = sym->st_value;
9071                 }
9072               val += rel->r_addend;
9073               val += sym_sec->output_section->vma + sym_sec->output_offset;
9074
9075               /* We don't yet know the exact toc pointer value, but we
9076                  know it will be somewhere in the toc section.  Don't
9077                  optimize if the difference from any possible toc
9078                  pointer is outside [ff..f80008000, 7fff7fff].  */
9079               addr = toc->output_section->vma + TOC_BASE_OFF;
9080               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9081                 continue;
9082
9083               addr = toc->output_section->vma + toc->output_section->rawsize;
9084               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9085                 continue;
9086
9087               if (skip == NULL)
9088                 {
9089                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9090                   if (skip == NULL)
9091                     goto error_ret;
9092                 }
9093
9094               skip[rel->r_offset >> 3]
9095                 |= can_optimize | ((rel - toc_relocs) << 2);
9096             }
9097         }
9098
9099       if (skip == NULL)
9100         continue;
9101
9102       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9103       if (used == NULL)
9104         {
9105         error_ret:
9106           if (local_syms != NULL
9107               && symtab_hdr->contents != (unsigned char *) local_syms)
9108             free (local_syms);
9109           if (sec != NULL
9110               && relstart != NULL
9111               && elf_section_data (sec)->relocs != relstart)
9112             free (relstart);
9113           if (toc_relocs != NULL
9114               && elf_section_data (toc)->relocs != toc_relocs)
9115             free (toc_relocs);
9116           if (skip != NULL)
9117             free (skip);
9118           return FALSE;
9119         }
9120
9121       /* Now check all kept sections that might reference the toc.
9122          Check the toc itself last.  */
9123       for (sec = (ibfd->sections == toc && toc->next ? toc->next
9124                   : ibfd->sections);
9125            sec != NULL;
9126            sec = (sec == toc ? NULL
9127                   : sec->next == NULL ? toc
9128                   : sec->next == toc && toc->next ? toc->next
9129                   : sec->next))
9130         {
9131           int repeat;
9132
9133           if (sec->reloc_count == 0
9134               || discarded_section (sec)
9135               || get_opd_info (sec)
9136               || (sec->flags & SEC_ALLOC) == 0
9137               || (sec->flags & SEC_DEBUGGING) != 0)
9138             continue;
9139
9140           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9141                                                 info->keep_memory);
9142           if (relstart == NULL)
9143             {
9144               free (used);
9145               goto error_ret;
9146             }
9147
9148           /* Mark toc entries referenced as used.  */
9149           do
9150             {
9151               repeat = 0;
9152               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9153                 {
9154                   enum elf_ppc64_reloc_type r_type;
9155                   unsigned long r_symndx;
9156                   asection *sym_sec;
9157                   struct elf_link_hash_entry *h;
9158                   Elf_Internal_Sym *sym;
9159                   bfd_vma val;
9160                   enum {no_check, check_lo, check_ha} insn_check;
9161
9162                   r_type = ELF64_R_TYPE (rel->r_info);
9163                   switch (r_type)
9164                     {
9165                     default:
9166                       insn_check = no_check;
9167                       break;
9168
9169                     case R_PPC64_GOT_TLSLD16_HA:
9170                     case R_PPC64_GOT_TLSGD16_HA:
9171                     case R_PPC64_GOT_TPREL16_HA:
9172                     case R_PPC64_GOT_DTPREL16_HA:
9173                     case R_PPC64_GOT16_HA:
9174                     case R_PPC64_TOC16_HA:
9175                       insn_check = check_ha;
9176                       break;
9177
9178                     case R_PPC64_GOT_TLSLD16_LO:
9179                     case R_PPC64_GOT_TLSGD16_LO:
9180                     case R_PPC64_GOT_TPREL16_LO_DS:
9181                     case R_PPC64_GOT_DTPREL16_LO_DS:
9182                     case R_PPC64_GOT16_LO:
9183                     case R_PPC64_GOT16_LO_DS:
9184                     case R_PPC64_TOC16_LO:
9185                     case R_PPC64_TOC16_LO_DS:
9186                       insn_check = check_lo;
9187                       break;
9188                     }
9189
9190                   if (insn_check != no_check)
9191                     {
9192                       bfd_vma off = rel->r_offset & ~3;
9193                       unsigned char buf[4];
9194                       unsigned int insn;
9195
9196                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9197                         {
9198                           free (used);
9199                           goto error_ret;
9200                         }
9201                       insn = bfd_get_32 (ibfd, buf);
9202                       if (insn_check == check_lo
9203                           ? !ok_lo_toc_insn (insn)
9204                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9205                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9206                         {
9207                           char str[12];
9208
9209                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9210                           sprintf (str, "%#08x", insn);
9211                           info->callbacks->einfo
9212                             /* xgettext:c-format */
9213                             (_("%P: %H: toc optimization is not supported for"
9214                                " %s instruction.\n"),
9215                              ibfd, sec, rel->r_offset & ~3, str);
9216                         }
9217                     }
9218
9219                   switch (r_type)
9220                     {
9221                     case R_PPC64_TOC16:
9222                     case R_PPC64_TOC16_LO:
9223                     case R_PPC64_TOC16_HI:
9224                     case R_PPC64_TOC16_HA:
9225                     case R_PPC64_TOC16_DS:
9226                     case R_PPC64_TOC16_LO_DS:
9227                       /* In case we're taking addresses of toc entries.  */
9228                     case R_PPC64_ADDR64:
9229                       break;
9230
9231                     default:
9232                       continue;
9233                     }
9234
9235                   r_symndx = ELF64_R_SYM (rel->r_info);
9236                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9237                                   r_symndx, ibfd))
9238                     {
9239                       free (used);
9240                       goto error_ret;
9241                     }
9242
9243                   if (sym_sec != toc)
9244                     continue;
9245
9246                   if (h != NULL)
9247                     val = h->root.u.def.value;
9248                   else
9249                     val = sym->st_value;
9250                   val += rel->r_addend;
9251
9252                   if (val >= toc->size)
9253                     continue;
9254
9255                   if ((skip[val >> 3] & can_optimize) != 0)
9256                     {
9257                       bfd_vma off;
9258                       unsigned char opc;
9259
9260                       switch (r_type)
9261                         {
9262                         case R_PPC64_TOC16_HA:
9263                           break;
9264
9265                         case R_PPC64_TOC16_LO_DS:
9266                           off = rel->r_offset;
9267                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9268                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9269                                                          off, 1))
9270                             {
9271                               free (used);
9272                               goto error_ret;
9273                             }
9274                           if ((opc & (0x3f << 2)) == (58u << 2))
9275                             break;
9276                           /* Fall through.  */
9277
9278                         default:
9279                           /* Wrong sort of reloc, or not a ld.  We may
9280                              as well clear ref_from_discarded too.  */
9281                           skip[val >> 3] = 0;
9282                         }
9283                     }
9284
9285                   if (sec != toc)
9286                     used[val >> 3] = 1;
9287                   /* For the toc section, we only mark as used if this
9288                      entry itself isn't unused.  */
9289                   else if ((used[rel->r_offset >> 3]
9290                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9291                            && !used[val >> 3])
9292                     {
9293                       /* Do all the relocs again, to catch reference
9294                          chains.  */
9295                       repeat = 1;
9296                       used[val >> 3] = 1;
9297                     }
9298                 }
9299             }
9300           while (repeat);
9301
9302           if (elf_section_data (sec)->relocs != relstart)
9303             free (relstart);
9304         }
9305
9306       /* Merge the used and skip arrays.  Assume that TOC
9307          doublewords not appearing as either used or unused belong
9308          to to an entry more than one doubleword in size.  */
9309       for (drop = skip, keep = used, last = 0, some_unused = 0;
9310            drop < skip + (toc->size + 7) / 8;
9311            ++drop, ++keep)
9312         {
9313           if (*keep)
9314             {
9315               *drop &= ~ref_from_discarded;
9316               if ((*drop & can_optimize) != 0)
9317                 some_unused = 1;
9318               last = 0;
9319             }
9320           else if ((*drop & ref_from_discarded) != 0)
9321             {
9322               some_unused = 1;
9323               last = ref_from_discarded;
9324             }
9325           else
9326             *drop = last;
9327         }
9328
9329       free (used);
9330
9331       if (some_unused)
9332         {
9333           bfd_byte *contents, *src;
9334           unsigned long off;
9335           Elf_Internal_Sym *sym;
9336           bfd_boolean local_toc_syms = FALSE;
9337
9338           /* Shuffle the toc contents, and at the same time convert the
9339              skip array from booleans into offsets.  */
9340           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9341             goto error_ret;
9342
9343           elf_section_data (toc)->this_hdr.contents = contents;
9344
9345           for (src = contents, off = 0, drop = skip;
9346                src < contents + toc->size;
9347                src += 8, ++drop)
9348             {
9349               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9350                 off += 8;
9351               else if (off != 0)
9352                 {
9353                   *drop = off;
9354                   memcpy (src - off, src, 8);
9355                 }
9356             }
9357           *drop = off;
9358           toc->rawsize = toc->size;
9359           toc->size = src - contents - off;
9360
9361           /* Adjust addends for relocs against the toc section sym,
9362              and optimize any accesses we can.  */
9363           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9364             {
9365               if (sec->reloc_count == 0
9366                   || discarded_section (sec))
9367                 continue;
9368
9369               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9370                                                     info->keep_memory);
9371               if (relstart == NULL)
9372                 goto error_ret;
9373
9374               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9375                 {
9376                   enum elf_ppc64_reloc_type r_type;
9377                   unsigned long r_symndx;
9378                   asection *sym_sec;
9379                   struct elf_link_hash_entry *h;
9380                   bfd_vma val;
9381
9382                   r_type = ELF64_R_TYPE (rel->r_info);
9383                   switch (r_type)
9384                     {
9385                     default:
9386                       continue;
9387
9388                     case R_PPC64_TOC16:
9389                     case R_PPC64_TOC16_LO:
9390                     case R_PPC64_TOC16_HI:
9391                     case R_PPC64_TOC16_HA:
9392                     case R_PPC64_TOC16_DS:
9393                     case R_PPC64_TOC16_LO_DS:
9394                     case R_PPC64_ADDR64:
9395                       break;
9396                     }
9397
9398                   r_symndx = ELF64_R_SYM (rel->r_info);
9399                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9400                                   r_symndx, ibfd))
9401                     goto error_ret;
9402
9403                   if (sym_sec != toc)
9404                     continue;
9405
9406                   if (h != NULL)
9407                     val = h->root.u.def.value;
9408                   else
9409                     {
9410                       val = sym->st_value;
9411                       if (val != 0)
9412                         local_toc_syms = TRUE;
9413                     }
9414
9415                   val += rel->r_addend;
9416
9417                   if (val > toc->rawsize)
9418                     val = toc->rawsize;
9419                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9420                     continue;
9421                   else if ((skip[val >> 3] & can_optimize) != 0)
9422                     {
9423                       Elf_Internal_Rela *tocrel
9424                         = toc_relocs + (skip[val >> 3] >> 2);
9425                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9426
9427                       switch (r_type)
9428                         {
9429                         case R_PPC64_TOC16_HA:
9430                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9431                           break;
9432
9433                         case R_PPC64_TOC16_LO_DS:
9434                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9435                           break;
9436
9437                         default:
9438                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9439                             ppc_howto_init ();
9440                           info->callbacks->einfo
9441                             /* xgettext:c-format */
9442                             (_("%P: %H: %s references "
9443                                "optimized away TOC entry\n"),
9444                              ibfd, sec, rel->r_offset,
9445                              ppc64_elf_howto_table[r_type]->name);
9446                           bfd_set_error (bfd_error_bad_value);
9447                           goto error_ret;
9448                         }
9449                       rel->r_addend = tocrel->r_addend;
9450                       elf_section_data (sec)->relocs = relstart;
9451                       continue;
9452                     }
9453
9454                   if (h != NULL || sym->st_value != 0)
9455                     continue;
9456
9457                   rel->r_addend -= skip[val >> 3];
9458                   elf_section_data (sec)->relocs = relstart;
9459                 }
9460
9461               if (elf_section_data (sec)->relocs != relstart)
9462                 free (relstart);
9463             }
9464
9465           /* We shouldn't have local or global symbols defined in the TOC,
9466              but handle them anyway.  */
9467           if (local_syms != NULL)
9468             for (sym = local_syms;
9469                  sym < local_syms + symtab_hdr->sh_info;
9470                  ++sym)
9471               if (sym->st_value != 0
9472                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9473                 {
9474                   unsigned long i;
9475
9476                   if (sym->st_value > toc->rawsize)
9477                     i = toc->rawsize >> 3;
9478                   else
9479                     i = sym->st_value >> 3;
9480
9481                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9482                     {
9483                       if (local_toc_syms)
9484                         _bfd_error_handler
9485                           (_("%s defined on removed toc entry"),
9486                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9487                       do
9488                         ++i;
9489                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9490                       sym->st_value = (bfd_vma) i << 3;
9491                     }
9492
9493                   sym->st_value -= skip[i];
9494                   symtab_hdr->contents = (unsigned char *) local_syms;
9495                 }
9496
9497           /* Adjust any global syms defined in this toc input section.  */
9498           if (toc_inf.global_toc_syms)
9499             {
9500               toc_inf.toc = toc;
9501               toc_inf.skip = skip;
9502               toc_inf.global_toc_syms = FALSE;
9503               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9504                                       &toc_inf);
9505             }
9506
9507           if (toc->reloc_count != 0)
9508             {
9509               Elf_Internal_Shdr *rel_hdr;
9510               Elf_Internal_Rela *wrel;
9511               bfd_size_type sz;
9512
9513               /* Remove unused toc relocs, and adjust those we keep.  */
9514               if (toc_relocs == NULL)
9515                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9516                                                         info->keep_memory);
9517               if (toc_relocs == NULL)
9518                 goto error_ret;
9519
9520               wrel = toc_relocs;
9521               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9522                 if ((skip[rel->r_offset >> 3]
9523                      & (ref_from_discarded | can_optimize)) == 0)
9524                   {
9525                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9526                     wrel->r_info = rel->r_info;
9527                     wrel->r_addend = rel->r_addend;
9528                     ++wrel;
9529                   }
9530                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9531                                             &local_syms, NULL, NULL))
9532                   goto error_ret;
9533
9534               elf_section_data (toc)->relocs = toc_relocs;
9535               toc->reloc_count = wrel - toc_relocs;
9536               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9537               sz = rel_hdr->sh_entsize;
9538               rel_hdr->sh_size = toc->reloc_count * sz;
9539             }
9540         }
9541       else if (toc_relocs != NULL
9542                && elf_section_data (toc)->relocs != toc_relocs)
9543         free (toc_relocs);
9544
9545       if (local_syms != NULL
9546           && symtab_hdr->contents != (unsigned char *) local_syms)
9547         {
9548           if (!info->keep_memory)
9549             free (local_syms);
9550           else
9551             symtab_hdr->contents = (unsigned char *) local_syms;
9552         }
9553       free (skip);
9554     }
9555
9556   return TRUE;
9557 }
9558
9559 /* Return true iff input section I references the TOC using
9560    instructions limited to +/-32k offsets.  */
9561
9562 bfd_boolean
9563 ppc64_elf_has_small_toc_reloc (asection *i)
9564 {
9565   return (is_ppc64_elf (i->owner)
9566           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9567 }
9568
9569 /* Allocate space for one GOT entry.  */
9570
9571 static void
9572 allocate_got (struct elf_link_hash_entry *h,
9573               struct bfd_link_info *info,
9574               struct got_entry *gent)
9575 {
9576   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9577   bfd_boolean dyn;
9578   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9579   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9580                  ? 16 : 8);
9581   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9582                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9583   asection *got = ppc64_elf_tdata (gent->owner)->got;
9584
9585   gent->got.offset = got->size;
9586   got->size += entsize;
9587
9588   dyn = htab->elf.dynamic_sections_created;
9589   if (h->type == STT_GNU_IFUNC)
9590     {
9591       htab->elf.irelplt->size += rentsize;
9592       htab->got_reli_size += rentsize;
9593     }
9594   else if ((bfd_link_pic (info)
9595             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9596            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9597                || h->root.type != bfd_link_hash_undefweak))
9598     {
9599       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9600       relgot->size += rentsize;
9601     }
9602 }
9603
9604 /* This function merges got entries in the same toc group.  */
9605
9606 static void
9607 merge_got_entries (struct got_entry **pent)
9608 {
9609   struct got_entry *ent, *ent2;
9610
9611   for (ent = *pent; ent != NULL; ent = ent->next)
9612     if (!ent->is_indirect)
9613       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9614         if (!ent2->is_indirect
9615             && ent2->addend == ent->addend
9616             && ent2->tls_type == ent->tls_type
9617             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9618           {
9619             ent2->is_indirect = TRUE;
9620             ent2->got.ent = ent;
9621           }
9622 }
9623
9624 /* Allocate space in .plt, .got and associated reloc sections for
9625    dynamic relocs.  */
9626
9627 static bfd_boolean
9628 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9629 {
9630   struct bfd_link_info *info;
9631   struct ppc_link_hash_table *htab;
9632   asection *s;
9633   struct ppc_link_hash_entry *eh;
9634   struct got_entry **pgent, *gent;
9635
9636   if (h->root.type == bfd_link_hash_indirect)
9637     return TRUE;
9638
9639   info = (struct bfd_link_info *) inf;
9640   htab = ppc_hash_table (info);
9641   if (htab == NULL)
9642     return FALSE;
9643
9644   eh = (struct ppc_link_hash_entry *) h;
9645   /* Run through the TLS GD got entries first if we're changing them
9646      to TPREL.  */
9647   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9648     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9649       if (gent->got.refcount > 0
9650           && (gent->tls_type & TLS_GD) != 0)
9651         {
9652           /* This was a GD entry that has been converted to TPREL.  If
9653              there happens to be a TPREL entry we can use that one.  */
9654           struct got_entry *ent;
9655           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9656             if (ent->got.refcount > 0
9657                 && (ent->tls_type & TLS_TPREL) != 0
9658                 && ent->addend == gent->addend
9659                 && ent->owner == gent->owner)
9660               {
9661                 gent->got.refcount = 0;
9662                 break;
9663               }
9664
9665           /* If not, then we'll be using our own TPREL entry.  */
9666           if (gent->got.refcount != 0)
9667             gent->tls_type = TLS_TLS | TLS_TPREL;
9668         }
9669
9670   /* Remove any list entry that won't generate a word in the GOT before
9671      we call merge_got_entries.  Otherwise we risk merging to empty
9672      entries.  */
9673   pgent = &h->got.glist;
9674   while ((gent = *pgent) != NULL)
9675     if (gent->got.refcount > 0)
9676       {
9677         if ((gent->tls_type & TLS_LD) != 0
9678             && !h->def_dynamic)
9679           {
9680             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9681             *pgent = gent->next;
9682           }
9683         else
9684           pgent = &gent->next;
9685       }
9686     else
9687       *pgent = gent->next;
9688
9689   if (!htab->do_multi_toc)
9690     merge_got_entries (&h->got.glist);
9691
9692   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9693     if (!gent->is_indirect)
9694       {
9695         /* Make sure this symbol is output as a dynamic symbol.
9696            Undefined weak syms won't yet be marked as dynamic,
9697            nor will all TLS symbols.  */
9698         if (h->dynindx == -1
9699             && !h->forced_local
9700             && h->type != STT_GNU_IFUNC
9701             && htab->elf.dynamic_sections_created)
9702           {
9703             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9704               return FALSE;
9705           }
9706
9707         if (!is_ppc64_elf (gent->owner))
9708           abort ();
9709
9710         allocate_got (h, info, gent);
9711       }
9712
9713   if (!htab->elf.dynamic_sections_created
9714       && h->type != STT_GNU_IFUNC)
9715     eh->dyn_relocs = NULL;
9716
9717   if (eh->dyn_relocs != NULL)
9718     {
9719       struct elf_dyn_relocs *p, **pp;
9720
9721       /* In the shared -Bsymbolic case, discard space allocated for
9722          dynamic pc-relative relocs against symbols which turn out to
9723          be defined in regular objects.  For the normal shared case,
9724          discard space for relocs that have become local due to symbol
9725          visibility changes.  */
9726
9727       if (bfd_link_pic (info))
9728         {
9729           /* Relocs that use pc_count are those that appear on a call
9730              insn, or certain REL relocs (see must_be_dyn_reloc) that
9731              can be generated via assembly.  We want calls to
9732              protected symbols to resolve directly to the function
9733              rather than going via the plt.  If people want function
9734              pointer comparisons to work as expected then they should
9735              avoid writing weird assembly.  */
9736           if (SYMBOL_CALLS_LOCAL (info, h))
9737             {
9738               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9739                 {
9740                   p->count -= p->pc_count;
9741                   p->pc_count = 0;
9742                   if (p->count == 0)
9743                     *pp = p->next;
9744                   else
9745                     pp = &p->next;
9746                 }
9747             }
9748
9749           /* Also discard relocs on undefined weak syms with
9750              non-default visibility.  */
9751           if (eh->dyn_relocs != NULL
9752               && h->root.type == bfd_link_hash_undefweak)
9753             {
9754               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9755                 eh->dyn_relocs = NULL;
9756
9757               /* Make sure this symbol is output as a dynamic symbol.
9758                  Undefined weak syms won't yet be marked as dynamic.  */
9759               else if (h->dynindx == -1
9760                        && !h->forced_local)
9761                 {
9762                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
9763                     return FALSE;
9764                 }
9765             }
9766         }
9767       else if (h->type == STT_GNU_IFUNC)
9768         {
9769           /* A plt entry is always created when making direct calls to
9770              an ifunc, even when building a static executable, but
9771              that doesn't cover all cases.  We may have only an ifunc
9772              initialised function pointer for a given ifunc symbol.
9773
9774              For ELFv2, dynamic relocations are not required when
9775              generating a global entry PLT stub.  */
9776           if (abiversion (info->output_bfd) >= 2)
9777             {
9778               if (global_entry_stub (h))
9779                 eh->dyn_relocs = NULL;
9780             }
9781
9782           /* For ELFv1 we have function descriptors.  Descriptors need
9783              to be treated like PLT entries and thus have dynamic
9784              relocations.  One exception is when the function
9785              descriptor is copied into .dynbss (which should only
9786              happen with ancient versions of gcc).  */
9787           else if (h->needs_copy)
9788             eh->dyn_relocs = NULL;
9789         }
9790       else if (ELIMINATE_COPY_RELOCS)
9791         {
9792           /* For the non-pic case, discard space for relocs against
9793              symbols which turn out to need copy relocs or are not
9794              dynamic.  */
9795
9796           /* First make sure this symbol is output as a dynamic symbol.
9797              Undefined weak syms won't yet be marked as dynamic.  */
9798           if (h->root.type == bfd_link_hash_undefweak
9799               && !h->non_got_ref
9800               && !h->def_regular
9801               && h->dynindx == -1
9802               && !h->forced_local
9803               && !bfd_elf_link_record_dynamic_symbol (info, h))
9804             return FALSE;
9805
9806           if (h->non_got_ref
9807               || h->def_regular
9808               || h->dynindx == -1)
9809             eh->dyn_relocs = NULL;
9810         }
9811
9812       /* Finally, allocate space.  */
9813       for (p = eh->dyn_relocs; p != NULL; p = p->next)
9814         {
9815           asection *sreloc = elf_section_data (p->sec)->sreloc;
9816           if (eh->elf.type == STT_GNU_IFUNC)
9817             sreloc = htab->elf.irelplt;
9818           sreloc->size += p->count * sizeof (Elf64_External_Rela);
9819         }
9820     }
9821
9822   if ((htab->elf.dynamic_sections_created
9823        && h->dynindx != -1
9824        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9825       || h->type == STT_GNU_IFUNC)
9826     {
9827       struct plt_entry *pent;
9828       bfd_boolean doneone = FALSE;
9829       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9830         if (pent->plt.refcount > 0)
9831           {
9832             if (!htab->elf.dynamic_sections_created
9833                 || h->dynindx == -1)
9834               {
9835                 s = htab->elf.iplt;
9836                 pent->plt.offset = s->size;
9837                 s->size += PLT_ENTRY_SIZE (htab);
9838                 s = htab->elf.irelplt;
9839               }
9840             else
9841               {
9842                 /* If this is the first .plt entry, make room for the special
9843                    first entry.  */
9844                 s = htab->elf.splt;
9845                 if (s->size == 0)
9846                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9847
9848                 pent->plt.offset = s->size;
9849
9850                 /* Make room for this entry.  */
9851                 s->size += PLT_ENTRY_SIZE (htab);
9852
9853                 /* Make room for the .glink code.  */
9854                 s = htab->glink;
9855                 if (s->size == 0)
9856                   s->size += GLINK_CALL_STUB_SIZE;
9857                 if (htab->opd_abi)
9858                   {
9859                     /* We need bigger stubs past index 32767.  */
9860                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9861                       s->size += 4;
9862                     s->size += 2*4;
9863                   }
9864                 else
9865                   s->size += 4;
9866
9867                 /* We also need to make an entry in the .rela.plt section.  */
9868                 s = htab->elf.srelplt;
9869               }
9870             s->size += sizeof (Elf64_External_Rela);
9871             doneone = TRUE;
9872           }
9873         else
9874           pent->plt.offset = (bfd_vma) -1;
9875       if (!doneone)
9876         {
9877           h->plt.plist = NULL;
9878           h->needs_plt = 0;
9879         }
9880     }
9881   else
9882     {
9883       h->plt.plist = NULL;
9884       h->needs_plt = 0;
9885     }
9886
9887   return TRUE;
9888 }
9889
9890 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9891    to set up space for global entry stubs.  These are put in glink,
9892    after the branch table.  */
9893
9894 static bfd_boolean
9895 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9896 {
9897   struct bfd_link_info *info;
9898   struct ppc_link_hash_table *htab;
9899   struct plt_entry *pent;
9900   asection *s;
9901
9902   if (h->root.type == bfd_link_hash_indirect)
9903     return TRUE;
9904
9905   if (!h->pointer_equality_needed)
9906     return TRUE;
9907
9908   if (h->def_regular)
9909     return TRUE;
9910
9911   info = inf;
9912   htab = ppc_hash_table (info);
9913   if (htab == NULL)
9914     return FALSE;
9915
9916   s = htab->glink;
9917   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9918     if (pent->plt.offset != (bfd_vma) -1
9919         && pent->addend == 0)
9920       {
9921         /* For ELFv2, if this symbol is not defined in a regular file
9922            and we are not generating a shared library or pie, then we
9923            need to define the symbol in the executable on a call stub.
9924            This is to avoid text relocations.  */
9925         s->size = (s->size + 15) & -16;
9926         h->root.type = bfd_link_hash_defined;
9927         h->root.u.def.section = s;
9928         h->root.u.def.value = s->size;
9929         s->size += 16;
9930         break;
9931       }
9932   return TRUE;
9933 }
9934
9935 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9936    read-only sections.  */
9937
9938 static bfd_boolean
9939 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9940 {
9941   if (h->root.type == bfd_link_hash_indirect)
9942     return TRUE;
9943
9944   if (readonly_dynrelocs (h))
9945     {
9946       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9947
9948       /* Not an error, just cut short the traversal.  */
9949       return FALSE;
9950     }
9951   return TRUE;
9952 }
9953
9954 /* Set the sizes of the dynamic sections.  */
9955
9956 static bfd_boolean
9957 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9958                                  struct bfd_link_info *info)
9959 {
9960   struct ppc_link_hash_table *htab;
9961   bfd *dynobj;
9962   asection *s;
9963   bfd_boolean relocs;
9964   bfd *ibfd;
9965   struct got_entry *first_tlsld;
9966
9967   htab = ppc_hash_table (info);
9968   if (htab == NULL)
9969     return FALSE;
9970
9971   dynobj = htab->elf.dynobj;
9972   if (dynobj == NULL)
9973     abort ();
9974
9975   if (htab->elf.dynamic_sections_created)
9976     {
9977       /* Set the contents of the .interp section to the interpreter.  */
9978       if (bfd_link_executable (info) && !info->nointerp)
9979         {
9980           s = bfd_get_linker_section (dynobj, ".interp");
9981           if (s == NULL)
9982             abort ();
9983           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9984           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9985         }
9986     }
9987
9988   /* Set up .got offsets for local syms, and space for local dynamic
9989      relocs.  */
9990   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9991     {
9992       struct got_entry **lgot_ents;
9993       struct got_entry **end_lgot_ents;
9994       struct plt_entry **local_plt;
9995       struct plt_entry **end_local_plt;
9996       unsigned char *lgot_masks;
9997       bfd_size_type locsymcount;
9998       Elf_Internal_Shdr *symtab_hdr;
9999
10000       if (!is_ppc64_elf (ibfd))
10001         continue;
10002
10003       for (s = ibfd->sections; s != NULL; s = s->next)
10004         {
10005           struct ppc_dyn_relocs *p;
10006
10007           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10008             {
10009               if (!bfd_is_abs_section (p->sec)
10010                   && bfd_is_abs_section (p->sec->output_section))
10011                 {
10012                   /* Input section has been discarded, either because
10013                      it is a copy of a linkonce section or due to
10014                      linker script /DISCARD/, so we'll be discarding
10015                      the relocs too.  */
10016                 }
10017               else if (p->count != 0)
10018                 {
10019                   asection *srel = elf_section_data (p->sec)->sreloc;
10020                   if (p->ifunc)
10021                     srel = htab->elf.irelplt;
10022                   srel->size += p->count * sizeof (Elf64_External_Rela);
10023                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10024                     info->flags |= DF_TEXTREL;
10025                 }
10026             }
10027         }
10028
10029       lgot_ents = elf_local_got_ents (ibfd);
10030       if (!lgot_ents)
10031         continue;
10032
10033       symtab_hdr = &elf_symtab_hdr (ibfd);
10034       locsymcount = symtab_hdr->sh_info;
10035       end_lgot_ents = lgot_ents + locsymcount;
10036       local_plt = (struct plt_entry **) end_lgot_ents;
10037       end_local_plt = local_plt + locsymcount;
10038       lgot_masks = (unsigned char *) end_local_plt;
10039       s = ppc64_elf_tdata (ibfd)->got;
10040       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10041         {
10042           struct got_entry **pent, *ent;
10043
10044           pent = lgot_ents;
10045           while ((ent = *pent) != NULL)
10046             if (ent->got.refcount > 0)
10047               {
10048                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10049                   {
10050                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
10051                     *pent = ent->next;
10052                   }
10053                 else
10054                   {
10055                     unsigned int ent_size = 8;
10056                     unsigned int rel_size = sizeof (Elf64_External_Rela);
10057
10058                     ent->got.offset = s->size;
10059                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10060                       {
10061                         ent_size *= 2;
10062                         rel_size *= 2;
10063                       }
10064                     s->size += ent_size;
10065                     if ((*lgot_masks & PLT_IFUNC) != 0)
10066                       {
10067                         htab->elf.irelplt->size += rel_size;
10068                         htab->got_reli_size += rel_size;
10069                       }
10070                     else if (bfd_link_pic (info))
10071                       {
10072                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10073                         srel->size += rel_size;
10074                       }
10075                     pent = &ent->next;
10076                   }
10077               }
10078             else
10079               *pent = ent->next;
10080         }
10081
10082       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
10083       for (; local_plt < end_local_plt; ++local_plt)
10084         {
10085           struct plt_entry *ent;
10086
10087           for (ent = *local_plt; ent != NULL; ent = ent->next)
10088             if (ent->plt.refcount > 0)
10089               {
10090                 s = htab->elf.iplt;
10091                 ent->plt.offset = s->size;
10092                 s->size += PLT_ENTRY_SIZE (htab);
10093
10094                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10095               }
10096             else
10097               ent->plt.offset = (bfd_vma) -1;
10098         }
10099     }
10100
10101   /* Allocate global sym .plt and .got entries, and space for global
10102      sym dynamic relocs.  */
10103   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10104   /* Stash the end of glink branch table.  */
10105   if (htab->glink != NULL)
10106     htab->glink->rawsize = htab->glink->size;
10107
10108   if (!htab->opd_abi && !bfd_link_pic (info))
10109     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10110
10111   first_tlsld = NULL;
10112   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10113     {
10114       struct got_entry *ent;
10115
10116       if (!is_ppc64_elf (ibfd))
10117         continue;
10118
10119       ent = ppc64_tlsld_got (ibfd);
10120       if (ent->got.refcount > 0)
10121         {
10122           if (!htab->do_multi_toc && first_tlsld != NULL)
10123             {
10124               ent->is_indirect = TRUE;
10125               ent->got.ent = first_tlsld;
10126             }
10127           else
10128             {
10129               if (first_tlsld == NULL)
10130                 first_tlsld = ent;
10131               s = ppc64_elf_tdata (ibfd)->got;
10132               ent->got.offset = s->size;
10133               ent->owner = ibfd;
10134               s->size += 16;
10135               if (bfd_link_pic (info))
10136                 {
10137                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10138                   srel->size += sizeof (Elf64_External_Rela);
10139                 }
10140             }
10141         }
10142       else
10143         ent->got.offset = (bfd_vma) -1;
10144     }
10145
10146   /* We now have determined the sizes of the various dynamic sections.
10147      Allocate memory for them.  */
10148   relocs = FALSE;
10149   for (s = dynobj->sections; s != NULL; s = s->next)
10150     {
10151       if ((s->flags & SEC_LINKER_CREATED) == 0)
10152         continue;
10153
10154       if (s == htab->brlt || s == htab->relbrlt)
10155         /* These haven't been allocated yet;  don't strip.  */
10156         continue;
10157       else if (s == htab->elf.sgot
10158                || s == htab->elf.splt
10159                || s == htab->elf.iplt
10160                || s == htab->glink
10161                || s == htab->dynbss)
10162         {
10163           /* Strip this section if we don't need it; see the
10164              comment below.  */
10165         }
10166       else if (s == htab->glink_eh_frame)
10167         {
10168           if (!bfd_is_abs_section (s->output_section))
10169             /* Not sized yet.  */
10170             continue;
10171         }
10172       else if (CONST_STRNEQ (s->name, ".rela"))
10173         {
10174           if (s->size != 0)
10175             {
10176               if (s != htab->elf.srelplt)
10177                 relocs = TRUE;
10178
10179               /* We use the reloc_count field as a counter if we need
10180                  to copy relocs into the output file.  */
10181               s->reloc_count = 0;
10182             }
10183         }
10184       else
10185         {
10186           /* It's not one of our sections, so don't allocate space.  */
10187           continue;
10188         }
10189
10190       if (s->size == 0)
10191         {
10192           /* If we don't need this section, strip it from the
10193              output file.  This is mostly to handle .rela.bss and
10194              .rela.plt.  We must create both sections in
10195              create_dynamic_sections, because they must be created
10196              before the linker maps input sections to output
10197              sections.  The linker does that before
10198              adjust_dynamic_symbol is called, and it is that
10199              function which decides whether anything needs to go
10200              into these sections.  */
10201           s->flags |= SEC_EXCLUDE;
10202           continue;
10203         }
10204
10205       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10206         continue;
10207
10208       /* Allocate memory for the section contents.  We use bfd_zalloc
10209          here in case unused entries are not reclaimed before the
10210          section's contents are written out.  This should not happen,
10211          but this way if it does we get a R_PPC64_NONE reloc in .rela
10212          sections instead of garbage.
10213          We also rely on the section contents being zero when writing
10214          the GOT.  */
10215       s->contents = bfd_zalloc (dynobj, s->size);
10216       if (s->contents == NULL)
10217         return FALSE;
10218     }
10219
10220   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10221     {
10222       if (!is_ppc64_elf (ibfd))
10223         continue;
10224
10225       s = ppc64_elf_tdata (ibfd)->got;
10226       if (s != NULL && s != htab->elf.sgot)
10227         {
10228           if (s->size == 0)
10229             s->flags |= SEC_EXCLUDE;
10230           else
10231             {
10232               s->contents = bfd_zalloc (ibfd, s->size);
10233               if (s->contents == NULL)
10234                 return FALSE;
10235             }
10236         }
10237       s = ppc64_elf_tdata (ibfd)->relgot;
10238       if (s != NULL)
10239         {
10240           if (s->size == 0)
10241             s->flags |= SEC_EXCLUDE;
10242           else
10243             {
10244               s->contents = bfd_zalloc (ibfd, s->size);
10245               if (s->contents == NULL)
10246                 return FALSE;
10247               relocs = TRUE;
10248               s->reloc_count = 0;
10249             }
10250         }
10251     }
10252
10253   if (htab->elf.dynamic_sections_created)
10254     {
10255       bfd_boolean tls_opt;
10256
10257       /* Add some entries to the .dynamic section.  We fill in the
10258          values later, in ppc64_elf_finish_dynamic_sections, but we
10259          must add the entries now so that we get the correct size for
10260          the .dynamic section.  The DT_DEBUG entry is filled in by the
10261          dynamic linker and used by the debugger.  */
10262 #define add_dynamic_entry(TAG, VAL) \
10263   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10264
10265       if (bfd_link_executable (info))
10266         {
10267           if (!add_dynamic_entry (DT_DEBUG, 0))
10268             return FALSE;
10269         }
10270
10271       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10272         {
10273           if (!add_dynamic_entry (DT_PLTGOT, 0)
10274               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10275               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10276               || !add_dynamic_entry (DT_JMPREL, 0)
10277               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10278             return FALSE;
10279         }
10280
10281       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10282         {
10283           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10284               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10285             return FALSE;
10286         }
10287
10288       tls_opt = (htab->params->tls_get_addr_opt
10289                  && htab->tls_get_addr_fd != NULL
10290                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10291       if (tls_opt || !htab->opd_abi)
10292         {
10293           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10294             return FALSE;
10295         }
10296
10297       if (relocs)
10298         {
10299           if (!add_dynamic_entry (DT_RELA, 0)
10300               || !add_dynamic_entry (DT_RELASZ, 0)
10301               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10302             return FALSE;
10303
10304           /* If any dynamic relocs apply to a read-only section,
10305              then we need a DT_TEXTREL entry.  */
10306           if ((info->flags & DF_TEXTREL) == 0)
10307             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10308
10309           if ((info->flags & DF_TEXTREL) != 0)
10310             {
10311               if (!add_dynamic_entry (DT_TEXTREL, 0))
10312                 return FALSE;
10313             }
10314         }
10315     }
10316 #undef add_dynamic_entry
10317
10318   return TRUE;
10319 }
10320
10321 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10322
10323 static bfd_boolean
10324 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10325 {
10326   if (h->plt.plist != NULL
10327       && !h->def_regular
10328       && !h->pointer_equality_needed)
10329     return FALSE;
10330
10331   return _bfd_elf_hash_symbol (h);
10332 }
10333
10334 /* Determine the type of stub needed, if any, for a call.  */
10335
10336 static inline enum ppc_stub_type
10337 ppc_type_of_stub (asection *input_sec,
10338                   const Elf_Internal_Rela *rel,
10339                   struct ppc_link_hash_entry **hash,
10340                   struct plt_entry **plt_ent,
10341                   bfd_vma destination,
10342                   unsigned long local_off)
10343 {
10344   struct ppc_link_hash_entry *h = *hash;
10345   bfd_vma location;
10346   bfd_vma branch_offset;
10347   bfd_vma max_branch_offset;
10348   enum elf_ppc64_reloc_type r_type;
10349
10350   if (h != NULL)
10351     {
10352       struct plt_entry *ent;
10353       struct ppc_link_hash_entry *fdh = h;
10354       if (h->oh != NULL
10355           && h->oh->is_func_descriptor)
10356         {
10357           fdh = ppc_follow_link (h->oh);
10358           *hash = fdh;
10359         }
10360
10361       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10362         if (ent->addend == rel->r_addend
10363             && ent->plt.offset != (bfd_vma) -1)
10364           {
10365             *plt_ent = ent;
10366             return ppc_stub_plt_call;
10367           }
10368
10369       /* Here, we know we don't have a plt entry.  If we don't have a
10370          either a defined function descriptor or a defined entry symbol
10371          in a regular object file, then it is pointless trying to make
10372          any other type of stub.  */
10373       if (!is_static_defined (&fdh->elf)
10374           && !is_static_defined (&h->elf))
10375         return ppc_stub_none;
10376     }
10377   else if (elf_local_got_ents (input_sec->owner) != NULL)
10378     {
10379       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10380       struct plt_entry **local_plt = (struct plt_entry **)
10381         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10382       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10383
10384       if (local_plt[r_symndx] != NULL)
10385         {
10386           struct plt_entry *ent;
10387
10388           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10389             if (ent->addend == rel->r_addend
10390                 && ent->plt.offset != (bfd_vma) -1)
10391               {
10392                 *plt_ent = ent;
10393                 return ppc_stub_plt_call;
10394               }
10395         }
10396     }
10397
10398   /* Determine where the call point is.  */
10399   location = (input_sec->output_offset
10400               + input_sec->output_section->vma
10401               + rel->r_offset);
10402
10403   branch_offset = destination - location;
10404   r_type = ELF64_R_TYPE (rel->r_info);
10405
10406   /* Determine if a long branch stub is needed.  */
10407   max_branch_offset = 1 << 25;
10408   if (r_type != R_PPC64_REL24)
10409     max_branch_offset = 1 << 15;
10410
10411   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10412     /* We need a stub.  Figure out whether a long_branch or plt_branch
10413        is needed later.  */
10414     return ppc_stub_long_branch;
10415
10416   return ppc_stub_none;
10417 }
10418
10419 /* With power7 weakly ordered memory model, it is possible for ld.so
10420    to update a plt entry in one thread and have another thread see a
10421    stale zero toc entry.  To avoid this we need some sort of acquire
10422    barrier in the call stub.  One solution is to make the load of the
10423    toc word seem to appear to depend on the load of the function entry
10424    word.  Another solution is to test for r2 being zero, and branch to
10425    the appropriate glink entry if so.
10426
10427    .    fake dep barrier        compare
10428    .    ld 12,xxx(2)            ld 12,xxx(2)
10429    .    mtctr 12                mtctr 12
10430    .    xor 11,12,12            ld 2,xxx+8(2)
10431    .    add 2,2,11              cmpldi 2,0
10432    .    ld 2,xxx+8(2)           bnectr+
10433    .    bctr                    b <glink_entry>
10434
10435    The solution involving the compare turns out to be faster, so
10436    that's what we use unless the branch won't reach.  */
10437
10438 #define ALWAYS_USE_FAKE_DEP 0
10439 #define ALWAYS_EMIT_R2SAVE 0
10440
10441 #define PPC_LO(v) ((v) & 0xffff)
10442 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10443 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10444
10445 static inline unsigned int
10446 plt_stub_size (struct ppc_link_hash_table *htab,
10447                struct ppc_stub_hash_entry *stub_entry,
10448                bfd_vma off)
10449 {
10450   unsigned size = 12;
10451
10452   if (ALWAYS_EMIT_R2SAVE
10453       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10454     size += 4;
10455   if (PPC_HA (off) != 0)
10456     size += 4;
10457   if (htab->opd_abi)
10458     {
10459       size += 4;
10460       if (htab->params->plt_static_chain)
10461         size += 4;
10462       if (htab->params->plt_thread_safe
10463           && htab->elf.dynamic_sections_created
10464           && stub_entry->h != NULL
10465           && stub_entry->h->elf.dynindx != -1)
10466         size += 8;
10467       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10468         size += 4;
10469     }
10470   if (stub_entry->h != NULL
10471       && (stub_entry->h == htab->tls_get_addr_fd
10472           || stub_entry->h == htab->tls_get_addr)
10473       && htab->params->tls_get_addr_opt)
10474     size += 13 * 4;
10475   return size;
10476 }
10477
10478 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10479    then return the padding needed to do so.  */
10480 static inline unsigned int
10481 plt_stub_pad (struct ppc_link_hash_table *htab,
10482               struct ppc_stub_hash_entry *stub_entry,
10483               bfd_vma plt_off)
10484 {
10485   int stub_align = 1 << htab->params->plt_stub_align;
10486   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10487   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10488
10489   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10490       > ((stub_size - 1) & -stub_align))
10491     return stub_align - (stub_off & (stub_align - 1));
10492   return 0;
10493 }
10494
10495 /* Build a .plt call stub.  */
10496
10497 static inline bfd_byte *
10498 build_plt_stub (struct ppc_link_hash_table *htab,
10499                 struct ppc_stub_hash_entry *stub_entry,
10500                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10501 {
10502   bfd *obfd = htab->params->stub_bfd;
10503   bfd_boolean plt_load_toc = htab->opd_abi;
10504   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10505   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10506                                  && htab->elf.dynamic_sections_created
10507                                  && stub_entry->h != NULL
10508                                  && stub_entry->h->elf.dynindx != -1);
10509   bfd_boolean use_fake_dep = plt_thread_safe;
10510   bfd_vma cmp_branch_off = 0;
10511
10512   if (!ALWAYS_USE_FAKE_DEP
10513       && plt_load_toc
10514       && plt_thread_safe
10515       && !((stub_entry->h == htab->tls_get_addr_fd
10516             || stub_entry->h == htab->tls_get_addr)
10517            && htab->params->tls_get_addr_opt))
10518     {
10519       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10520       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10521                           / PLT_ENTRY_SIZE (htab));
10522       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10523       bfd_vma to, from;
10524
10525       if (pltindex > 32768)
10526         glinkoff += (pltindex - 32768) * 4;
10527       to = (glinkoff
10528             + htab->glink->output_offset
10529             + htab->glink->output_section->vma);
10530       from = (p - stub_entry->group->stub_sec->contents
10531               + 4 * (ALWAYS_EMIT_R2SAVE
10532                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10533               + 4 * (PPC_HA (offset) != 0)
10534               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10535                      != PPC_HA (offset))
10536               + 4 * (plt_static_chain != 0)
10537               + 20
10538               + stub_entry->group->stub_sec->output_offset
10539               + stub_entry->group->stub_sec->output_section->vma);
10540       cmp_branch_off = to - from;
10541       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10542     }
10543
10544   if (PPC_HA (offset) != 0)
10545     {
10546       if (r != NULL)
10547         {
10548           if (ALWAYS_EMIT_R2SAVE
10549               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10550             r[0].r_offset += 4;
10551           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10552           r[1].r_offset = r[0].r_offset + 4;
10553           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10554           r[1].r_addend = r[0].r_addend;
10555           if (plt_load_toc)
10556             {
10557               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10558                 {
10559                   r[2].r_offset = r[1].r_offset + 4;
10560                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10561                   r[2].r_addend = r[0].r_addend;
10562                 }
10563               else
10564                 {
10565                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10566                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10567                   r[2].r_addend = r[0].r_addend + 8;
10568                   if (plt_static_chain)
10569                     {
10570                       r[3].r_offset = r[2].r_offset + 4;
10571                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10572                       r[3].r_addend = r[0].r_addend + 16;
10573                     }
10574                 }
10575             }
10576         }
10577       if (ALWAYS_EMIT_R2SAVE
10578           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10579         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10580       if (plt_load_toc)
10581         {
10582           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10583           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10584         }
10585       else
10586         {
10587           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10588           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10589         }
10590       if (plt_load_toc
10591           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10592         {
10593           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10594           offset = 0;
10595         }
10596       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10597       if (plt_load_toc)
10598         {
10599           if (use_fake_dep)
10600             {
10601               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10602               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10603             }
10604           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10605           if (plt_static_chain)
10606             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10607         }
10608     }
10609   else
10610     {
10611       if (r != NULL)
10612         {
10613           if (ALWAYS_EMIT_R2SAVE
10614               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10615             r[0].r_offset += 4;
10616           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10617           if (plt_load_toc)
10618             {
10619               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10620                 {
10621                   r[1].r_offset = r[0].r_offset + 4;
10622                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10623                   r[1].r_addend = r[0].r_addend;
10624                 }
10625               else
10626                 {
10627                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10628                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10629                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10630                   if (plt_static_chain)
10631                     {
10632                       r[2].r_offset = r[1].r_offset + 4;
10633                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10634                       r[2].r_addend = r[0].r_addend + 8;
10635                     }
10636                 }
10637             }
10638         }
10639       if (ALWAYS_EMIT_R2SAVE
10640           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10641         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10642       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10643       if (plt_load_toc
10644           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10645         {
10646           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10647           offset = 0;
10648         }
10649       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10650       if (plt_load_toc)
10651         {
10652           if (use_fake_dep)
10653             {
10654               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10655               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10656             }
10657           if (plt_static_chain)
10658             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10659           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10660         }
10661     }
10662   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10663     {
10664       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10665       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10666       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10667     }
10668   else
10669     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10670   return p;
10671 }
10672
10673 /* Build a special .plt call stub for __tls_get_addr.  */
10674
10675 #define LD_R11_0R3      0xe9630000
10676 #define LD_R12_0R3      0xe9830000
10677 #define MR_R0_R3        0x7c601b78
10678 #define CMPDI_R11_0     0x2c2b0000
10679 #define ADD_R3_R12_R13  0x7c6c6a14
10680 #define BEQLR           0x4d820020
10681 #define MR_R3_R0        0x7c030378
10682 #define STD_R11_0R1     0xf9610000
10683 #define BCTRL           0x4e800421
10684 #define LD_R11_0R1      0xe9610000
10685 #define MTLR_R11        0x7d6803a6
10686
10687 static inline bfd_byte *
10688 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10689                          struct ppc_stub_hash_entry *stub_entry,
10690                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10691 {
10692   bfd *obfd = htab->params->stub_bfd;
10693
10694   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10695   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10696   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10697   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10698   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10699   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10700   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10701   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10702   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10703
10704   if (r != NULL)
10705     r[0].r_offset += 9 * 4;
10706   p = build_plt_stub (htab, stub_entry, p, offset, r);
10707   bfd_put_32 (obfd, BCTRL, p - 4);
10708
10709   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10710   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10711   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10712   bfd_put_32 (obfd, BLR, p),                    p += 4;
10713
10714   return p;
10715 }
10716
10717 static Elf_Internal_Rela *
10718 get_relocs (asection *sec, int count)
10719 {
10720   Elf_Internal_Rela *relocs;
10721   struct bfd_elf_section_data *elfsec_data;
10722
10723   elfsec_data = elf_section_data (sec);
10724   relocs = elfsec_data->relocs;
10725   if (relocs == NULL)
10726     {
10727       bfd_size_type relsize;
10728       relsize = sec->reloc_count * sizeof (*relocs);
10729       relocs = bfd_alloc (sec->owner, relsize);
10730       if (relocs == NULL)
10731         return NULL;
10732       elfsec_data->relocs = relocs;
10733       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10734                                           sizeof (Elf_Internal_Shdr));
10735       if (elfsec_data->rela.hdr == NULL)
10736         return NULL;
10737       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10738                                         * sizeof (Elf64_External_Rela));
10739       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10740       sec->reloc_count = 0;
10741     }
10742   relocs += sec->reloc_count;
10743   sec->reloc_count += count;
10744   return relocs;
10745 }
10746
10747 static bfd_vma
10748 get_r2off (struct bfd_link_info *info,
10749            struct ppc_stub_hash_entry *stub_entry)
10750 {
10751   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10752   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10753
10754   if (r2off == 0)
10755     {
10756       /* Support linking -R objects.  Get the toc pointer from the
10757          opd entry.  */
10758       char buf[8];
10759       if (!htab->opd_abi)
10760         return r2off;
10761       asection *opd = stub_entry->h->elf.root.u.def.section;
10762       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10763
10764       if (strcmp (opd->name, ".opd") != 0
10765           || opd->reloc_count != 0)
10766         {
10767           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10768                                   stub_entry->h->elf.root.root.string);
10769           bfd_set_error (bfd_error_bad_value);
10770           return (bfd_vma) -1;
10771         }
10772       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10773         return (bfd_vma) -1;
10774       r2off = bfd_get_64 (opd->owner, buf);
10775       r2off -= elf_gp (info->output_bfd);
10776     }
10777   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10778   return r2off;
10779 }
10780
10781 static bfd_boolean
10782 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10783 {
10784   struct ppc_stub_hash_entry *stub_entry;
10785   struct ppc_branch_hash_entry *br_entry;
10786   struct bfd_link_info *info;
10787   struct ppc_link_hash_table *htab;
10788   bfd_byte *loc;
10789   bfd_byte *p;
10790   bfd_vma dest, off;
10791   int size;
10792   Elf_Internal_Rela *r;
10793   asection *plt;
10794
10795   /* Massage our args to the form they really have.  */
10796   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10797   info = in_arg;
10798
10799   htab = ppc_hash_table (info);
10800   if (htab == NULL)
10801     return FALSE;
10802
10803   /* Make a note of the offset within the stubs for this entry.  */
10804   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10805   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10806
10807   htab->stub_count[stub_entry->stub_type - 1] += 1;
10808   switch (stub_entry->stub_type)
10809     {
10810     case ppc_stub_long_branch:
10811     case ppc_stub_long_branch_r2off:
10812       /* Branches are relative.  This is where we are going to.  */
10813       dest = (stub_entry->target_value
10814               + stub_entry->target_section->output_offset
10815               + stub_entry->target_section->output_section->vma);
10816       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10817       off = dest;
10818
10819       /* And this is where we are coming from.  */
10820       off -= (stub_entry->stub_offset
10821               + stub_entry->group->stub_sec->output_offset
10822               + stub_entry->group->stub_sec->output_section->vma);
10823
10824       size = 4;
10825       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10826         {
10827           bfd_vma r2off = get_r2off (info, stub_entry);
10828
10829           if (r2off == (bfd_vma) -1)
10830             {
10831               htab->stub_error = TRUE;
10832               return FALSE;
10833             }
10834           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10835           loc += 4;
10836           size = 8;
10837           if (PPC_HA (r2off) != 0)
10838             {
10839               bfd_put_32 (htab->params->stub_bfd,
10840                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10841               loc += 4;
10842               size += 4;
10843             }
10844           if (PPC_LO (r2off) != 0)
10845             {
10846               bfd_put_32 (htab->params->stub_bfd,
10847                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10848               loc += 4;
10849               size += 4;
10850             }
10851           off -= size - 4;
10852         }
10853       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10854
10855       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10856         {
10857           info->callbacks->einfo
10858             (_("%P: long branch stub `%s' offset overflow\n"),
10859              stub_entry->root.string);
10860           htab->stub_error = TRUE;
10861           return FALSE;
10862         }
10863
10864       if (info->emitrelocations)
10865         {
10866           r = get_relocs (stub_entry->group->stub_sec, 1);
10867           if (r == NULL)
10868             return FALSE;
10869           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10870           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10871           r->r_addend = dest;
10872           if (stub_entry->h != NULL)
10873             {
10874               struct elf_link_hash_entry **hashes;
10875               unsigned long symndx;
10876               struct ppc_link_hash_entry *h;
10877
10878               hashes = elf_sym_hashes (htab->params->stub_bfd);
10879               if (hashes == NULL)
10880                 {
10881                   bfd_size_type hsize;
10882
10883                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10884                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10885                   if (hashes == NULL)
10886                     return FALSE;
10887                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10888                   htab->stub_globals = 1;
10889                 }
10890               symndx = htab->stub_globals++;
10891               h = stub_entry->h;
10892               hashes[symndx] = &h->elf;
10893               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10894               if (h->oh != NULL && h->oh->is_func)
10895                 h = ppc_follow_link (h->oh);
10896               if (h->elf.root.u.def.section != stub_entry->target_section)
10897                 /* H is an opd symbol.  The addend must be zero.  */
10898                 r->r_addend = 0;
10899               else
10900                 {
10901                   off = (h->elf.root.u.def.value
10902                          + h->elf.root.u.def.section->output_offset
10903                          + h->elf.root.u.def.section->output_section->vma);
10904                   r->r_addend -= off;
10905                 }
10906             }
10907         }
10908       break;
10909
10910     case ppc_stub_plt_branch:
10911     case ppc_stub_plt_branch_r2off:
10912       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10913                                          stub_entry->root.string + 9,
10914                                          FALSE, FALSE);
10915       if (br_entry == NULL)
10916         {
10917           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10918                                   stub_entry->root.string);
10919           htab->stub_error = TRUE;
10920           return FALSE;
10921         }
10922
10923       dest = (stub_entry->target_value
10924               + stub_entry->target_section->output_offset
10925               + stub_entry->target_section->output_section->vma);
10926       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10927         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10928
10929       bfd_put_64 (htab->brlt->owner, dest,
10930                   htab->brlt->contents + br_entry->offset);
10931
10932       if (br_entry->iter == htab->stub_iteration)
10933         {
10934           br_entry->iter = 0;
10935
10936           if (htab->relbrlt != NULL)
10937             {
10938               /* Create a reloc for the branch lookup table entry.  */
10939               Elf_Internal_Rela rela;
10940               bfd_byte *rl;
10941
10942               rela.r_offset = (br_entry->offset
10943                                + htab->brlt->output_offset
10944                                + htab->brlt->output_section->vma);
10945               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10946               rela.r_addend = dest;
10947
10948               rl = htab->relbrlt->contents;
10949               rl += (htab->relbrlt->reloc_count++
10950                      * sizeof (Elf64_External_Rela));
10951               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10952             }
10953           else if (info->emitrelocations)
10954             {
10955               r = get_relocs (htab->brlt, 1);
10956               if (r == NULL)
10957                 return FALSE;
10958               /* brlt, being SEC_LINKER_CREATED does not go through the
10959                  normal reloc processing.  Symbols and offsets are not
10960                  translated from input file to output file form, so
10961                  set up the offset per the output file.  */
10962               r->r_offset = (br_entry->offset
10963                              + htab->brlt->output_offset
10964                              + htab->brlt->output_section->vma);
10965               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10966               r->r_addend = dest;
10967             }
10968         }
10969
10970       dest = (br_entry->offset
10971               + htab->brlt->output_offset
10972               + htab->brlt->output_section->vma);
10973
10974       off = (dest
10975              - elf_gp (htab->brlt->output_section->owner)
10976              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10977
10978       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10979         {
10980           info->callbacks->einfo
10981             (_("%P: linkage table error against `%T'\n"),
10982              stub_entry->root.string);
10983           bfd_set_error (bfd_error_bad_value);
10984           htab->stub_error = TRUE;
10985           return FALSE;
10986         }
10987
10988       if (info->emitrelocations)
10989         {
10990           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10991           if (r == NULL)
10992             return FALSE;
10993           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10994           if (bfd_big_endian (info->output_bfd))
10995             r[0].r_offset += 2;
10996           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10997             r[0].r_offset += 4;
10998           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10999           r[0].r_addend = dest;
11000           if (PPC_HA (off) != 0)
11001             {
11002               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11003               r[1].r_offset = r[0].r_offset + 4;
11004               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11005               r[1].r_addend = r[0].r_addend;
11006             }
11007         }
11008
11009       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11010         {
11011           if (PPC_HA (off) != 0)
11012             {
11013               size = 16;
11014               bfd_put_32 (htab->params->stub_bfd,
11015                           ADDIS_R12_R2 | PPC_HA (off), loc);
11016               loc += 4;
11017               bfd_put_32 (htab->params->stub_bfd,
11018                           LD_R12_0R12 | PPC_LO (off), loc);
11019             }
11020           else
11021             {
11022               size = 12;
11023               bfd_put_32 (htab->params->stub_bfd,
11024                           LD_R12_0R2 | PPC_LO (off), loc);
11025             }
11026         }
11027       else
11028         {
11029           bfd_vma r2off = get_r2off (info, stub_entry);
11030
11031           if (r2off == (bfd_vma) -1)
11032             {
11033               htab->stub_error = TRUE;
11034               return FALSE;
11035             }
11036
11037           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11038           loc += 4;
11039           size = 16;
11040           if (PPC_HA (off) != 0)
11041             {
11042               size += 4;
11043               bfd_put_32 (htab->params->stub_bfd,
11044                           ADDIS_R12_R2 | PPC_HA (off), loc);
11045               loc += 4;
11046               bfd_put_32 (htab->params->stub_bfd,
11047                           LD_R12_0R12 | PPC_LO (off), loc);
11048             }
11049           else
11050             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11051
11052           if (PPC_HA (r2off) != 0)
11053             {
11054               size += 4;
11055               loc += 4;
11056               bfd_put_32 (htab->params->stub_bfd,
11057                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
11058             }
11059           if (PPC_LO (r2off) != 0)
11060             {
11061               size += 4;
11062               loc += 4;
11063               bfd_put_32 (htab->params->stub_bfd,
11064                           ADDI_R2_R2 | PPC_LO (r2off), loc);
11065             }
11066         }
11067       loc += 4;
11068       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11069       loc += 4;
11070       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11071       break;
11072
11073     case ppc_stub_plt_call:
11074     case ppc_stub_plt_call_r2save:
11075       if (stub_entry->h != NULL
11076           && stub_entry->h->is_func_descriptor
11077           && stub_entry->h->oh != NULL)
11078         {
11079           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11080
11081           /* If the old-ABI "dot-symbol" is undefined make it weak so
11082              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
11083           if (fh->elf.root.type == bfd_link_hash_undefined)
11084             fh->elf.root.type = bfd_link_hash_undefweak;
11085           /* Stop undo_symbol_twiddle changing it back to undefined.  */
11086           fh->was_undefined = 0;
11087         }
11088
11089       /* Now build the stub.  */
11090       dest = stub_entry->plt_ent->plt.offset & ~1;
11091       if (dest >= (bfd_vma) -2)
11092         abort ();
11093
11094       plt = htab->elf.splt;
11095       if (!htab->elf.dynamic_sections_created
11096           || stub_entry->h == NULL
11097           || stub_entry->h->elf.dynindx == -1)
11098         plt = htab->elf.iplt;
11099
11100       dest += plt->output_offset + plt->output_section->vma;
11101
11102       if (stub_entry->h == NULL
11103           && (stub_entry->plt_ent->plt.offset & 1) == 0)
11104         {
11105           Elf_Internal_Rela rela;
11106           bfd_byte *rl;
11107
11108           rela.r_offset = dest;
11109           if (htab->opd_abi)
11110             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11111           else
11112             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11113           rela.r_addend = (stub_entry->target_value
11114                            + stub_entry->target_section->output_offset
11115                            + stub_entry->target_section->output_section->vma);
11116
11117           rl = (htab->elf.irelplt->contents
11118                 + (htab->elf.irelplt->reloc_count++
11119                    * sizeof (Elf64_External_Rela)));
11120           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11121           stub_entry->plt_ent->plt.offset |= 1;
11122         }
11123
11124       off = (dest
11125              - elf_gp (plt->output_section->owner)
11126              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11127
11128       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11129         {
11130           info->callbacks->einfo
11131             /* xgettext:c-format */
11132             (_("%P: linkage table error against `%T'\n"),
11133              stub_entry->h != NULL
11134              ? stub_entry->h->elf.root.root.string
11135              : "<local sym>");
11136           bfd_set_error (bfd_error_bad_value);
11137           htab->stub_error = TRUE;
11138           return FALSE;
11139         }
11140
11141       if (htab->params->plt_stub_align != 0)
11142         {
11143           unsigned pad = plt_stub_pad (htab, stub_entry, off);
11144
11145           stub_entry->group->stub_sec->size += pad;
11146           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11147           loc += pad;
11148         }
11149
11150       r = NULL;
11151       if (info->emitrelocations)
11152         {
11153           r = get_relocs (stub_entry->group->stub_sec,
11154                           ((PPC_HA (off) != 0)
11155                            + (htab->opd_abi
11156                               ? 2 + (htab->params->plt_static_chain
11157                                      && PPC_HA (off + 16) == PPC_HA (off))
11158                               : 1)));
11159           if (r == NULL)
11160             return FALSE;
11161           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11162           if (bfd_big_endian (info->output_bfd))
11163             r[0].r_offset += 2;
11164           r[0].r_addend = dest;
11165         }
11166       if (stub_entry->h != NULL
11167           && (stub_entry->h == htab->tls_get_addr_fd
11168               || stub_entry->h == htab->tls_get_addr)
11169           && htab->params->tls_get_addr_opt)
11170         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11171       else
11172         p = build_plt_stub (htab, stub_entry, loc, off, r);
11173       size = p - loc;
11174       break;
11175
11176     case ppc_stub_save_res:
11177       return TRUE;
11178
11179     default:
11180       BFD_FAIL ();
11181       return FALSE;
11182     }
11183
11184   stub_entry->group->stub_sec->size += size;
11185
11186   if (htab->params->emit_stub_syms)
11187     {
11188       struct elf_link_hash_entry *h;
11189       size_t len1, len2;
11190       char *name;
11191       const char *const stub_str[] = { "long_branch",
11192                                        "long_branch_r2off",
11193                                        "plt_branch",
11194                                        "plt_branch_r2off",
11195                                        "plt_call",
11196                                        "plt_call" };
11197
11198       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11199       len2 = strlen (stub_entry->root.string);
11200       name = bfd_malloc (len1 + len2 + 2);
11201       if (name == NULL)
11202         return FALSE;
11203       memcpy (name, stub_entry->root.string, 9);
11204       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11205       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11206       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11207       if (h == NULL)
11208         return FALSE;
11209       if (h->root.type == bfd_link_hash_new)
11210         {
11211           h->root.type = bfd_link_hash_defined;
11212           h->root.u.def.section = stub_entry->group->stub_sec;
11213           h->root.u.def.value = stub_entry->stub_offset;
11214           h->ref_regular = 1;
11215           h->def_regular = 1;
11216           h->ref_regular_nonweak = 1;
11217           h->forced_local = 1;
11218           h->non_elf = 0;
11219           h->root.linker_def = 1;
11220         }
11221     }
11222
11223   return TRUE;
11224 }
11225
11226 /* As above, but don't actually build the stub.  Just bump offset so
11227    we know stub section sizes, and select plt_branch stubs where
11228    long_branch stubs won't do.  */
11229
11230 static bfd_boolean
11231 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11232 {
11233   struct ppc_stub_hash_entry *stub_entry;
11234   struct bfd_link_info *info;
11235   struct ppc_link_hash_table *htab;
11236   bfd_vma off;
11237   int size;
11238
11239   /* Massage our args to the form they really have.  */
11240   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11241   info = in_arg;
11242
11243   htab = ppc_hash_table (info);
11244   if (htab == NULL)
11245     return FALSE;
11246
11247   if (stub_entry->h != NULL
11248       && stub_entry->h->save_res
11249       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11250       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11251     {
11252       /* Don't make stubs to out-of-line register save/restore
11253          functions.  Instead, emit copies of the functions.  */
11254       stub_entry->group->needs_save_res = 1;
11255       stub_entry->stub_type = ppc_stub_save_res;
11256       return TRUE;
11257     }
11258
11259   if (stub_entry->stub_type == ppc_stub_plt_call
11260       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11261     {
11262       asection *plt;
11263       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11264       if (off >= (bfd_vma) -2)
11265         abort ();
11266       plt = htab->elf.splt;
11267       if (!htab->elf.dynamic_sections_created
11268           || stub_entry->h == NULL
11269           || stub_entry->h->elf.dynindx == -1)
11270         plt = htab->elf.iplt;
11271       off += (plt->output_offset
11272               + plt->output_section->vma
11273               - elf_gp (plt->output_section->owner)
11274               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11275
11276       size = plt_stub_size (htab, stub_entry, off);
11277       if (htab->params->plt_stub_align)
11278         size += plt_stub_pad (htab, stub_entry, off);
11279       if (info->emitrelocations)
11280         {
11281           stub_entry->group->stub_sec->reloc_count
11282             += ((PPC_HA (off) != 0)
11283                 + (htab->opd_abi
11284                    ? 2 + (htab->params->plt_static_chain
11285                           && PPC_HA (off + 16) == PPC_HA (off))
11286                    : 1));
11287           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11288         }
11289     }
11290   else
11291     {
11292       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11293          variants.  */
11294       bfd_vma r2off = 0;
11295       bfd_vma local_off = 0;
11296
11297       off = (stub_entry->target_value
11298              + stub_entry->target_section->output_offset
11299              + stub_entry->target_section->output_section->vma);
11300       off -= (stub_entry->group->stub_sec->size
11301               + stub_entry->group->stub_sec->output_offset
11302               + stub_entry->group->stub_sec->output_section->vma);
11303
11304       /* Reset the stub type from the plt variant in case we now
11305          can reach with a shorter stub.  */
11306       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11307         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11308
11309       size = 4;
11310       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11311         {
11312           r2off = get_r2off (info, stub_entry);
11313           if (r2off == (bfd_vma) -1)
11314             {
11315               htab->stub_error = TRUE;
11316               return FALSE;
11317             }
11318           size = 8;
11319           if (PPC_HA (r2off) != 0)
11320             size += 4;
11321           if (PPC_LO (r2off) != 0)
11322             size += 4;
11323           off -= size - 4;
11324         }
11325
11326       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11327
11328       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11329          Do the same for -R objects without function descriptors.  */
11330       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11331           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11332               && r2off == 0
11333               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11334         {
11335           struct ppc_branch_hash_entry *br_entry;
11336
11337           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11338                                              stub_entry->root.string + 9,
11339                                              TRUE, FALSE);
11340           if (br_entry == NULL)
11341             {
11342               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11343                                       stub_entry->root.string);
11344               htab->stub_error = TRUE;
11345               return FALSE;
11346             }
11347
11348           if (br_entry->iter != htab->stub_iteration)
11349             {
11350               br_entry->iter = htab->stub_iteration;
11351               br_entry->offset = htab->brlt->size;
11352               htab->brlt->size += 8;
11353
11354               if (htab->relbrlt != NULL)
11355                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11356               else if (info->emitrelocations)
11357                 {
11358                   htab->brlt->reloc_count += 1;
11359                   htab->brlt->flags |= SEC_RELOC;
11360                 }
11361             }
11362
11363           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11364           off = (br_entry->offset
11365                  + htab->brlt->output_offset
11366                  + htab->brlt->output_section->vma
11367                  - elf_gp (htab->brlt->output_section->owner)
11368                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11369
11370           if (info->emitrelocations)
11371             {
11372               stub_entry->group->stub_sec->reloc_count
11373                 += 1 + (PPC_HA (off) != 0);
11374               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11375             }
11376
11377           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11378             {
11379               size = 12;
11380               if (PPC_HA (off) != 0)
11381                 size = 16;
11382             }
11383           else
11384             {
11385               size = 16;
11386               if (PPC_HA (off) != 0)
11387                 size += 4;
11388
11389               if (PPC_HA (r2off) != 0)
11390                 size += 4;
11391               if (PPC_LO (r2off) != 0)
11392                 size += 4;
11393             }
11394         }
11395       else if (info->emitrelocations)
11396         {
11397           stub_entry->group->stub_sec->reloc_count += 1;
11398           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11399         }
11400     }
11401
11402   stub_entry->group->stub_sec->size += size;
11403   return TRUE;
11404 }
11405
11406 /* Set up various things so that we can make a list of input sections
11407    for each output section included in the link.  Returns -1 on error,
11408    0 when no stubs will be needed, and 1 on success.  */
11409
11410 int
11411 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11412 {
11413   unsigned int id;
11414   bfd_size_type amt;
11415   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11416
11417   if (htab == NULL)
11418     return -1;
11419
11420   htab->sec_info_arr_size = bfd_get_next_section_id ();
11421   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11422   htab->sec_info = bfd_zmalloc (amt);
11423   if (htab->sec_info == NULL)
11424     return -1;
11425
11426   /* Set toc_off for com, und, abs and ind sections.  */
11427   for (id = 0; id < 3; id++)
11428     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11429
11430   return 1;
11431 }
11432
11433 /* Set up for first pass at multitoc partitioning.  */
11434
11435 void
11436 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11437 {
11438   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11439
11440   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11441   htab->toc_bfd = NULL;
11442   htab->toc_first_sec = NULL;
11443 }
11444
11445 /* The linker repeatedly calls this function for each TOC input section
11446    and linker generated GOT section.  Group input bfds such that the toc
11447    within a group is less than 64k in size.  */
11448
11449 bfd_boolean
11450 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11451 {
11452   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11453   bfd_vma addr, off, limit;
11454
11455   if (htab == NULL)
11456     return FALSE;
11457
11458   if (!htab->second_toc_pass)
11459     {
11460       /* Keep track of the first .toc or .got section for this input bfd.  */
11461       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11462
11463       if (new_bfd)
11464         {
11465           htab->toc_bfd = isec->owner;
11466           htab->toc_first_sec = isec;
11467         }
11468
11469       addr = isec->output_offset + isec->output_section->vma;
11470       off = addr - htab->toc_curr;
11471       limit = 0x80008000;
11472       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11473         limit = 0x10000;
11474       if (off + isec->size > limit)
11475         {
11476           addr = (htab->toc_first_sec->output_offset
11477                   + htab->toc_first_sec->output_section->vma);
11478           htab->toc_curr = addr;
11479           htab->toc_curr &= -TOC_BASE_ALIGN;
11480         }
11481
11482       /* toc_curr is the base address of this toc group.  Set elf_gp
11483          for the input section to be the offset relative to the
11484          output toc base plus 0x8000.  Making the input elf_gp an
11485          offset allows us to move the toc as a whole without
11486          recalculating input elf_gp.  */
11487       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11488       off += TOC_BASE_OFF;
11489
11490       /* Die if someone uses a linker script that doesn't keep input
11491          file .toc and .got together.  */
11492       if (new_bfd
11493           && elf_gp (isec->owner) != 0
11494           && elf_gp (isec->owner) != off)
11495         return FALSE;
11496
11497       elf_gp (isec->owner) = off;
11498       return TRUE;
11499     }
11500
11501   /* During the second pass toc_first_sec points to the start of
11502      a toc group, and toc_curr is used to track the old elf_gp.
11503      We use toc_bfd to ensure we only look at each bfd once.  */
11504   if (htab->toc_bfd == isec->owner)
11505     return TRUE;
11506   htab->toc_bfd = isec->owner;
11507
11508   if (htab->toc_first_sec == NULL
11509       || htab->toc_curr != elf_gp (isec->owner))
11510     {
11511       htab->toc_curr = elf_gp (isec->owner);
11512       htab->toc_first_sec = isec;
11513     }
11514   addr = (htab->toc_first_sec->output_offset
11515           + htab->toc_first_sec->output_section->vma);
11516   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11517   elf_gp (isec->owner) = off;
11518
11519   return TRUE;
11520 }
11521
11522 /* Called via elf_link_hash_traverse to merge GOT entries for global
11523    symbol H.  */
11524
11525 static bfd_boolean
11526 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11527 {
11528   if (h->root.type == bfd_link_hash_indirect)
11529     return TRUE;
11530
11531   merge_got_entries (&h->got.glist);
11532
11533   return TRUE;
11534 }
11535
11536 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11537    symbol H.  */
11538
11539 static bfd_boolean
11540 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11541 {
11542   struct got_entry *gent;
11543
11544   if (h->root.type == bfd_link_hash_indirect)
11545     return TRUE;
11546
11547   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11548     if (!gent->is_indirect)
11549       allocate_got (h, (struct bfd_link_info *) inf, gent);
11550   return TRUE;
11551 }
11552
11553 /* Called on the first multitoc pass after the last call to
11554    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11555    entries.  */
11556
11557 bfd_boolean
11558 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11559 {
11560   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11561   struct bfd *ibfd, *ibfd2;
11562   bfd_boolean done_something;
11563
11564   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11565
11566   if (!htab->do_multi_toc)
11567     return FALSE;
11568
11569   /* Merge global sym got entries within a toc group.  */
11570   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11571
11572   /* And tlsld_got.  */
11573   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11574     {
11575       struct got_entry *ent, *ent2;
11576
11577       if (!is_ppc64_elf (ibfd))
11578         continue;
11579
11580       ent = ppc64_tlsld_got (ibfd);
11581       if (!ent->is_indirect
11582           && ent->got.offset != (bfd_vma) -1)
11583         {
11584           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11585             {
11586               if (!is_ppc64_elf (ibfd2))
11587                 continue;
11588
11589               ent2 = ppc64_tlsld_got (ibfd2);
11590               if (!ent2->is_indirect
11591                   && ent2->got.offset != (bfd_vma) -1
11592                   && elf_gp (ibfd2) == elf_gp (ibfd))
11593                 {
11594                   ent2->is_indirect = TRUE;
11595                   ent2->got.ent = ent;
11596                 }
11597             }
11598         }
11599     }
11600
11601   /* Zap sizes of got sections.  */
11602   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11603   htab->elf.irelplt->size -= htab->got_reli_size;
11604   htab->got_reli_size = 0;
11605
11606   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11607     {
11608       asection *got, *relgot;
11609
11610       if (!is_ppc64_elf (ibfd))
11611         continue;
11612
11613       got = ppc64_elf_tdata (ibfd)->got;
11614       if (got != NULL)
11615         {
11616           got->rawsize = got->size;
11617           got->size = 0;
11618           relgot = ppc64_elf_tdata (ibfd)->relgot;
11619           relgot->rawsize = relgot->size;
11620           relgot->size = 0;
11621         }
11622     }
11623
11624   /* Now reallocate the got, local syms first.  We don't need to
11625      allocate section contents again since we never increase size.  */
11626   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11627     {
11628       struct got_entry **lgot_ents;
11629       struct got_entry **end_lgot_ents;
11630       struct plt_entry **local_plt;
11631       struct plt_entry **end_local_plt;
11632       unsigned char *lgot_masks;
11633       bfd_size_type locsymcount;
11634       Elf_Internal_Shdr *symtab_hdr;
11635       asection *s;
11636
11637       if (!is_ppc64_elf (ibfd))
11638         continue;
11639
11640       lgot_ents = elf_local_got_ents (ibfd);
11641       if (!lgot_ents)
11642         continue;
11643
11644       symtab_hdr = &elf_symtab_hdr (ibfd);
11645       locsymcount = symtab_hdr->sh_info;
11646       end_lgot_ents = lgot_ents + locsymcount;
11647       local_plt = (struct plt_entry **) end_lgot_ents;
11648       end_local_plt = local_plt + locsymcount;
11649       lgot_masks = (unsigned char *) end_local_plt;
11650       s = ppc64_elf_tdata (ibfd)->got;
11651       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11652         {
11653           struct got_entry *ent;
11654
11655           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11656             {
11657               unsigned int ent_size = 8;
11658               unsigned int rel_size = sizeof (Elf64_External_Rela);
11659
11660               ent->got.offset = s->size;
11661               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11662                 {
11663                   ent_size *= 2;
11664                   rel_size *= 2;
11665                 }
11666               s->size += ent_size;
11667               if ((*lgot_masks & PLT_IFUNC) != 0)
11668                 {
11669                   htab->elf.irelplt->size += rel_size;
11670                   htab->got_reli_size += rel_size;
11671                 }
11672               else if (bfd_link_pic (info))
11673                 {
11674                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11675                   srel->size += rel_size;
11676                 }
11677             }
11678         }
11679     }
11680
11681   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11682
11683   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11684     {
11685       struct got_entry *ent;
11686
11687       if (!is_ppc64_elf (ibfd))
11688         continue;
11689
11690       ent = ppc64_tlsld_got (ibfd);
11691       if (!ent->is_indirect
11692           && ent->got.offset != (bfd_vma) -1)
11693         {
11694           asection *s = ppc64_elf_tdata (ibfd)->got;
11695           ent->got.offset = s->size;
11696           s->size += 16;
11697           if (bfd_link_pic (info))
11698             {
11699               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11700               srel->size += sizeof (Elf64_External_Rela);
11701             }
11702         }
11703     }
11704
11705   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11706   if (!done_something)
11707     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11708       {
11709         asection *got;
11710
11711         if (!is_ppc64_elf (ibfd))
11712           continue;
11713
11714         got = ppc64_elf_tdata (ibfd)->got;
11715         if (got != NULL)
11716           {
11717             done_something = got->rawsize != got->size;
11718             if (done_something)
11719               break;
11720           }
11721       }
11722
11723   if (done_something)
11724     (*htab->params->layout_sections_again) ();
11725
11726   /* Set up for second pass over toc sections to recalculate elf_gp
11727      on input sections.  */
11728   htab->toc_bfd = NULL;
11729   htab->toc_first_sec = NULL;
11730   htab->second_toc_pass = TRUE;
11731   return done_something;
11732 }
11733
11734 /* Called after second pass of multitoc partitioning.  */
11735
11736 void
11737 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11738 {
11739   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11740
11741   /* After the second pass, toc_curr tracks the TOC offset used
11742      for code sections below in ppc64_elf_next_input_section.  */
11743   htab->toc_curr = TOC_BASE_OFF;
11744 }
11745
11746 /* No toc references were found in ISEC.  If the code in ISEC makes no
11747    calls, then there's no need to use toc adjusting stubs when branching
11748    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11749    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11750    needed, and 2 if a cyclical call-graph was found but no other reason
11751    for a stub was detected.  If called from the top level, a return of
11752    2 means the same as a return of 0.  */
11753
11754 static int
11755 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11756 {
11757   int ret;
11758
11759   /* Mark this section as checked.  */
11760   isec->call_check_done = 1;
11761
11762   /* We know none of our code bearing sections will need toc stubs.  */
11763   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11764     return 0;
11765
11766   if (isec->size == 0)
11767     return 0;
11768
11769   if (isec->output_section == NULL)
11770     return 0;
11771
11772   ret = 0;
11773   if (isec->reloc_count != 0)
11774     {
11775       Elf_Internal_Rela *relstart, *rel;
11776       Elf_Internal_Sym *local_syms;
11777       struct ppc_link_hash_table *htab;
11778
11779       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11780                                             info->keep_memory);
11781       if (relstart == NULL)
11782         return -1;
11783
11784       /* Look for branches to outside of this section.  */
11785       local_syms = NULL;
11786       htab = ppc_hash_table (info);
11787       if (htab == NULL)
11788         return -1;
11789
11790       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11791         {
11792           enum elf_ppc64_reloc_type r_type;
11793           unsigned long r_symndx;
11794           struct elf_link_hash_entry *h;
11795           struct ppc_link_hash_entry *eh;
11796           Elf_Internal_Sym *sym;
11797           asection *sym_sec;
11798           struct _opd_sec_data *opd;
11799           bfd_vma sym_value;
11800           bfd_vma dest;
11801
11802           r_type = ELF64_R_TYPE (rel->r_info);
11803           if (r_type != R_PPC64_REL24
11804               && r_type != R_PPC64_REL14
11805               && r_type != R_PPC64_REL14_BRTAKEN
11806               && r_type != R_PPC64_REL14_BRNTAKEN)
11807             continue;
11808
11809           r_symndx = ELF64_R_SYM (rel->r_info);
11810           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11811                           isec->owner))
11812             {
11813               ret = -1;
11814               break;
11815             }
11816
11817           /* Calls to dynamic lib functions go through a plt call stub
11818              that uses r2.  */
11819           eh = (struct ppc_link_hash_entry *) h;
11820           if (eh != NULL
11821               && (eh->elf.plt.plist != NULL
11822                   || (eh->oh != NULL
11823                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11824             {
11825               ret = 1;
11826               break;
11827             }
11828
11829           if (sym_sec == NULL)
11830             /* Ignore other undefined symbols.  */
11831             continue;
11832
11833           /* Assume branches to other sections not included in the
11834              link need stubs too, to cover -R and absolute syms.  */
11835           if (sym_sec->output_section == NULL)
11836             {
11837               ret = 1;
11838               break;
11839             }
11840
11841           if (h == NULL)
11842             sym_value = sym->st_value;
11843           else
11844             {
11845               if (h->root.type != bfd_link_hash_defined
11846                   && h->root.type != bfd_link_hash_defweak)
11847                 abort ();
11848               sym_value = h->root.u.def.value;
11849             }
11850           sym_value += rel->r_addend;
11851
11852           /* If this branch reloc uses an opd sym, find the code section.  */
11853           opd = get_opd_info (sym_sec);
11854           if (opd != NULL)
11855             {
11856               if (h == NULL && opd->adjust != NULL)
11857                 {
11858                   long adjust;
11859
11860                   adjust = opd->adjust[OPD_NDX (sym_value)];
11861                   if (adjust == -1)
11862                     /* Assume deleted functions won't ever be called.  */
11863                     continue;
11864                   sym_value += adjust;
11865                 }
11866
11867               dest = opd_entry_value (sym_sec, sym_value,
11868                                       &sym_sec, NULL, FALSE);
11869               if (dest == (bfd_vma) -1)
11870                 continue;
11871             }
11872           else
11873             dest = (sym_value
11874                     + sym_sec->output_offset
11875                     + sym_sec->output_section->vma);
11876
11877           /* Ignore branch to self.  */
11878           if (sym_sec == isec)
11879             continue;
11880
11881           /* If the called function uses the toc, we need a stub.  */
11882           if (sym_sec->has_toc_reloc
11883               || sym_sec->makes_toc_func_call)
11884             {
11885               ret = 1;
11886               break;
11887             }
11888
11889           /* Assume any branch that needs a long branch stub might in fact
11890              need a plt_branch stub.  A plt_branch stub uses r2.  */
11891           else if (dest - (isec->output_offset
11892                            + isec->output_section->vma
11893                            + rel->r_offset) + (1 << 25)
11894                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11895                                                              ? h->other
11896                                                              : sym->st_other))
11897             {
11898               ret = 1;
11899               break;
11900             }
11901
11902           /* If calling back to a section in the process of being
11903              tested, we can't say for sure that no toc adjusting stubs
11904              are needed, so don't return zero.  */
11905           else if (sym_sec->call_check_in_progress)
11906             ret = 2;
11907
11908           /* Branches to another section that itself doesn't have any TOC
11909              references are OK.  Recursively call ourselves to check.  */
11910           else if (!sym_sec->call_check_done)
11911             {
11912               int recur;
11913
11914               /* Mark current section as indeterminate, so that other
11915                  sections that call back to current won't be marked as
11916                  known.  */
11917               isec->call_check_in_progress = 1;
11918               recur = toc_adjusting_stub_needed (info, sym_sec);
11919               isec->call_check_in_progress = 0;
11920
11921               if (recur != 0)
11922                 {
11923                   ret = recur;
11924                   if (recur != 2)
11925                     break;
11926                 }
11927             }
11928         }
11929
11930       if (local_syms != NULL
11931           && (elf_symtab_hdr (isec->owner).contents
11932               != (unsigned char *) local_syms))
11933         free (local_syms);
11934       if (elf_section_data (isec)->relocs != relstart)
11935         free (relstart);
11936     }
11937
11938   if ((ret & 1) == 0
11939       && isec->map_head.s != NULL
11940       && (strcmp (isec->output_section->name, ".init") == 0
11941           || strcmp (isec->output_section->name, ".fini") == 0))
11942     {
11943       if (isec->map_head.s->has_toc_reloc
11944           || isec->map_head.s->makes_toc_func_call)
11945         ret = 1;
11946       else if (!isec->map_head.s->call_check_done)
11947         {
11948           int recur;
11949           isec->call_check_in_progress = 1;
11950           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11951           isec->call_check_in_progress = 0;
11952           if (recur != 0)
11953             ret = recur;
11954         }
11955     }
11956
11957   if (ret == 1)
11958     isec->makes_toc_func_call = 1;
11959
11960   return ret;
11961 }
11962
11963 /* The linker repeatedly calls this function for each input section,
11964    in the order that input sections are linked into output sections.
11965    Build lists of input sections to determine groupings between which
11966    we may insert linker stubs.  */
11967
11968 bfd_boolean
11969 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11970 {
11971   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11972
11973   if (htab == NULL)
11974     return FALSE;
11975
11976   if ((isec->output_section->flags & SEC_CODE) != 0
11977       && isec->output_section->id < htab->sec_info_arr_size)
11978     {
11979       /* This happens to make the list in reverse order,
11980          which is what we want.  */
11981       htab->sec_info[isec->id].u.list
11982         = htab->sec_info[isec->output_section->id].u.list;
11983       htab->sec_info[isec->output_section->id].u.list = isec;
11984     }
11985
11986   if (htab->multi_toc_needed)
11987     {
11988       /* Analyse sections that aren't already flagged as needing a
11989          valid toc pointer.  Exclude .fixup for the linux kernel.
11990          .fixup contains branches, but only back to the function that
11991          hit an exception.  */
11992       if (!(isec->has_toc_reloc
11993             || (isec->flags & SEC_CODE) == 0
11994             || strcmp (isec->name, ".fixup") == 0
11995             || isec->call_check_done))
11996         {
11997           if (toc_adjusting_stub_needed (info, isec) < 0)
11998             return FALSE;
11999         }
12000       /* Make all sections use the TOC assigned for this object file.
12001          This will be wrong for pasted sections;  We fix that in
12002          check_pasted_section().  */
12003       if (elf_gp (isec->owner) != 0)
12004         htab->toc_curr = elf_gp (isec->owner);
12005     }
12006
12007   htab->sec_info[isec->id].toc_off = htab->toc_curr;
12008   return TRUE;
12009 }
12010
12011 /* Check that all .init and .fini sections use the same toc, if they
12012    have toc relocs.  */
12013
12014 static bfd_boolean
12015 check_pasted_section (struct bfd_link_info *info, const char *name)
12016 {
12017   asection *o = bfd_get_section_by_name (info->output_bfd, name);
12018
12019   if (o != NULL)
12020     {
12021       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12022       bfd_vma toc_off = 0;
12023       asection *i;
12024
12025       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12026         if (i->has_toc_reloc)
12027           {
12028             if (toc_off == 0)
12029               toc_off = htab->sec_info[i->id].toc_off;
12030             else if (toc_off != htab->sec_info[i->id].toc_off)
12031               return FALSE;
12032           }
12033
12034       if (toc_off == 0)
12035         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12036           if (i->makes_toc_func_call)
12037             {
12038               toc_off = htab->sec_info[i->id].toc_off;
12039               break;
12040             }
12041
12042       /* Make sure the whole pasted function uses the same toc offset.  */
12043       if (toc_off != 0)
12044         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12045           htab->sec_info[i->id].toc_off = toc_off;
12046     }
12047   return TRUE;
12048 }
12049
12050 bfd_boolean
12051 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12052 {
12053   return (check_pasted_section (info, ".init")
12054           & check_pasted_section (info, ".fini"));
12055 }
12056
12057 /* See whether we can group stub sections together.  Grouping stub
12058    sections may result in fewer stubs.  More importantly, we need to
12059    put all .init* and .fini* stubs at the beginning of the .init or
12060    .fini output sections respectively, because glibc splits the
12061    _init and _fini functions into multiple parts.  Putting a stub in
12062    the middle of a function is not a good idea.  */
12063
12064 static bfd_boolean
12065 group_sections (struct bfd_link_info *info,
12066                 bfd_size_type stub_group_size,
12067                 bfd_boolean stubs_always_before_branch)
12068 {
12069   struct ppc_link_hash_table *htab;
12070   asection *osec;
12071   bfd_boolean suppress_size_errors;
12072
12073   htab = ppc_hash_table (info);
12074   if (htab == NULL)
12075     return FALSE;
12076
12077   suppress_size_errors = FALSE;
12078   if (stub_group_size == 1)
12079     {
12080       /* Default values.  */
12081       if (stubs_always_before_branch)
12082         stub_group_size = 0x1e00000;
12083       else
12084         stub_group_size = 0x1c00000;
12085       suppress_size_errors = TRUE;
12086     }
12087
12088   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12089     {
12090       asection *tail;
12091
12092       if (osec->id >= htab->sec_info_arr_size)
12093         continue;
12094
12095       tail = htab->sec_info[osec->id].u.list;
12096       while (tail != NULL)
12097         {
12098           asection *curr;
12099           asection *prev;
12100           bfd_size_type total;
12101           bfd_boolean big_sec;
12102           bfd_vma curr_toc;
12103           struct map_stub *group;
12104           bfd_size_type group_size;
12105
12106           curr = tail;
12107           total = tail->size;
12108           group_size = (ppc64_elf_section_data (tail) != NULL
12109                         && ppc64_elf_section_data (tail)->has_14bit_branch
12110                         ? stub_group_size >> 10 : stub_group_size);
12111
12112           big_sec = total > group_size;
12113           if (big_sec && !suppress_size_errors)
12114             /* xgettext:c-format */
12115             _bfd_error_handler (_("%B section %A exceeds stub group size"),
12116                                 tail->owner, tail);
12117           curr_toc = htab->sec_info[tail->id].toc_off;
12118
12119           while ((prev = htab->sec_info[curr->id].u.list) != NULL
12120                  && ((total += curr->output_offset - prev->output_offset)
12121                      < (ppc64_elf_section_data (prev) != NULL
12122                         && ppc64_elf_section_data (prev)->has_14bit_branch
12123                         ? (group_size = stub_group_size >> 10) : group_size))
12124                  && htab->sec_info[prev->id].toc_off == curr_toc)
12125             curr = prev;
12126
12127           /* OK, the size from the start of CURR to the end is less
12128              than group_size and thus can be handled by one stub
12129              section.  (or the tail section is itself larger than
12130              group_size, in which case we may be toast.)  We should
12131              really be keeping track of the total size of stubs added
12132              here, as stubs contribute to the final output section
12133              size.  That's a little tricky, and this way will only
12134              break if stubs added make the total size more than 2^25,
12135              ie. for the default stub_group_size, if stubs total more
12136              than 2097152 bytes, or nearly 75000 plt call stubs.  */
12137           group = bfd_alloc (curr->owner, sizeof (*group));
12138           if (group == NULL)
12139             return FALSE;
12140           group->link_sec = curr;
12141           group->stub_sec = NULL;
12142           group->needs_save_res = 0;
12143           group->next = htab->group;
12144           htab->group = group;
12145           do
12146             {
12147               prev = htab->sec_info[tail->id].u.list;
12148               /* Set up this stub group.  */
12149               htab->sec_info[tail->id].u.group = group;
12150             }
12151           while (tail != curr && (tail = prev) != NULL);
12152
12153           /* But wait, there's more!  Input sections up to group_size
12154              bytes before the stub section can be handled by it too.
12155              Don't do this if we have a really large section after the
12156              stubs, as adding more stubs increases the chance that
12157              branches may not reach into the stub section.  */
12158           if (!stubs_always_before_branch && !big_sec)
12159             {
12160               total = 0;
12161               while (prev != NULL
12162                      && ((total += tail->output_offset - prev->output_offset)
12163                          < (ppc64_elf_section_data (prev) != NULL
12164                             && ppc64_elf_section_data (prev)->has_14bit_branch
12165                             ? (group_size = stub_group_size >> 10) : group_size))
12166                      && htab->sec_info[prev->id].toc_off == curr_toc)
12167                 {
12168                   tail = prev;
12169                   prev = htab->sec_info[tail->id].u.list;
12170                   htab->sec_info[tail->id].u.group = group;
12171                 }
12172             }
12173           tail = prev;
12174         }
12175     }
12176   return TRUE;
12177 }
12178
12179 static const unsigned char glink_eh_frame_cie[] =
12180 {
12181   0, 0, 0, 16,                          /* length.  */
12182   0, 0, 0, 0,                           /* id.  */
12183   1,                                    /* CIE version.  */
12184   'z', 'R', 0,                          /* Augmentation string.  */
12185   4,                                    /* Code alignment.  */
12186   0x78,                                 /* Data alignment.  */
12187   65,                                   /* RA reg.  */
12188   1,                                    /* Augmentation size.  */
12189   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12190   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12191   0, 0, 0, 0
12192 };
12193
12194 /* Stripping output sections is normally done before dynamic section
12195    symbols have been allocated.  This function is called later, and
12196    handles cases like htab->brlt which is mapped to its own output
12197    section.  */
12198
12199 static void
12200 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12201 {
12202   if (isec->size == 0
12203       && isec->output_section->size == 0
12204       && !(isec->output_section->flags & SEC_KEEP)
12205       && !bfd_section_removed_from_list (info->output_bfd,
12206                                          isec->output_section)
12207       && elf_section_data (isec->output_section)->dynindx == 0)
12208     {
12209       isec->output_section->flags |= SEC_EXCLUDE;
12210       bfd_section_list_remove (info->output_bfd, isec->output_section);
12211       info->output_bfd->section_count--;
12212     }
12213 }
12214
12215 /* Determine and set the size of the stub section for a final link.
12216
12217    The basic idea here is to examine all the relocations looking for
12218    PC-relative calls to a target that is unreachable with a "bl"
12219    instruction.  */
12220
12221 bfd_boolean
12222 ppc64_elf_size_stubs (struct bfd_link_info *info)
12223 {
12224   bfd_size_type stub_group_size;
12225   bfd_boolean stubs_always_before_branch;
12226   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12227
12228   if (htab == NULL)
12229     return FALSE;
12230
12231   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12232     htab->params->plt_thread_safe = 1;
12233   if (!htab->opd_abi)
12234     htab->params->plt_thread_safe = 0;
12235   else if (htab->params->plt_thread_safe == -1)
12236     {
12237       static const char *const thread_starter[] =
12238         {
12239           "pthread_create",
12240           /* libstdc++ */
12241           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12242           /* librt */
12243           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12244           "mq_notify", "create_timer",
12245           /* libanl */
12246           "getaddrinfo_a",
12247           /* libgomp */
12248           "GOMP_parallel",
12249           "GOMP_parallel_start",
12250           "GOMP_parallel_loop_static",
12251           "GOMP_parallel_loop_static_start",
12252           "GOMP_parallel_loop_dynamic",
12253           "GOMP_parallel_loop_dynamic_start",
12254           "GOMP_parallel_loop_guided",
12255           "GOMP_parallel_loop_guided_start",
12256           "GOMP_parallel_loop_runtime",
12257           "GOMP_parallel_loop_runtime_start",
12258           "GOMP_parallel_sections",
12259           "GOMP_parallel_sections_start",
12260           /* libgo */
12261           "__go_go",
12262         };
12263       unsigned i;
12264
12265       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12266         {
12267           struct elf_link_hash_entry *h;
12268           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12269                                     FALSE, FALSE, TRUE);
12270           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12271           if (htab->params->plt_thread_safe)
12272             break;
12273         }
12274     }
12275   stubs_always_before_branch = htab->params->group_size < 0;
12276   if (htab->params->group_size < 0)
12277     stub_group_size = -htab->params->group_size;
12278   else
12279     stub_group_size = htab->params->group_size;
12280
12281   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12282     return FALSE;
12283
12284 #define STUB_SHRINK_ITER 20
12285   /* Loop until no stubs added.  After iteration 20 of this loop we may
12286      exit on a stub section shrinking.  This is to break out of a
12287      pathological case where adding stubs on one iteration decreases
12288      section gaps (perhaps due to alignment), which then requires
12289      fewer or smaller stubs on the next iteration.  */
12290
12291   while (1)
12292     {
12293       bfd *input_bfd;
12294       unsigned int bfd_indx;
12295       struct map_stub *group;
12296       asection *stub_sec;
12297
12298       htab->stub_iteration += 1;
12299
12300       for (input_bfd = info->input_bfds, bfd_indx = 0;
12301            input_bfd != NULL;
12302            input_bfd = input_bfd->link.next, bfd_indx++)
12303         {
12304           Elf_Internal_Shdr *symtab_hdr;
12305           asection *section;
12306           Elf_Internal_Sym *local_syms = NULL;
12307
12308           if (!is_ppc64_elf (input_bfd))
12309             continue;
12310
12311           /* We'll need the symbol table in a second.  */
12312           symtab_hdr = &elf_symtab_hdr (input_bfd);
12313           if (symtab_hdr->sh_info == 0)
12314             continue;
12315
12316           /* Walk over each section attached to the input bfd.  */
12317           for (section = input_bfd->sections;
12318                section != NULL;
12319                section = section->next)
12320             {
12321               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12322
12323               /* If there aren't any relocs, then there's nothing more
12324                  to do.  */
12325               if ((section->flags & SEC_RELOC) == 0
12326                   || (section->flags & SEC_ALLOC) == 0
12327                   || (section->flags & SEC_LOAD) == 0
12328                   || (section->flags & SEC_CODE) == 0
12329                   || section->reloc_count == 0)
12330                 continue;
12331
12332               /* If this section is a link-once section that will be
12333                  discarded, then don't create any stubs.  */
12334               if (section->output_section == NULL
12335                   || section->output_section->owner != info->output_bfd)
12336                 continue;
12337
12338               /* Get the relocs.  */
12339               internal_relocs
12340                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12341                                              info->keep_memory);
12342               if (internal_relocs == NULL)
12343                 goto error_ret_free_local;
12344
12345               /* Now examine each relocation.  */
12346               irela = internal_relocs;
12347               irelaend = irela + section->reloc_count;
12348               for (; irela < irelaend; irela++)
12349                 {
12350                   enum elf_ppc64_reloc_type r_type;
12351                   unsigned int r_indx;
12352                   enum ppc_stub_type stub_type;
12353                   struct ppc_stub_hash_entry *stub_entry;
12354                   asection *sym_sec, *code_sec;
12355                   bfd_vma sym_value, code_value;
12356                   bfd_vma destination;
12357                   unsigned long local_off;
12358                   bfd_boolean ok_dest;
12359                   struct ppc_link_hash_entry *hash;
12360                   struct ppc_link_hash_entry *fdh;
12361                   struct elf_link_hash_entry *h;
12362                   Elf_Internal_Sym *sym;
12363                   char *stub_name;
12364                   const asection *id_sec;
12365                   struct _opd_sec_data *opd;
12366                   struct plt_entry *plt_ent;
12367
12368                   r_type = ELF64_R_TYPE (irela->r_info);
12369                   r_indx = ELF64_R_SYM (irela->r_info);
12370
12371                   if (r_type >= R_PPC64_max)
12372                     {
12373                       bfd_set_error (bfd_error_bad_value);
12374                       goto error_ret_free_internal;
12375                     }
12376
12377                   /* Only look for stubs on branch instructions.  */
12378                   if (r_type != R_PPC64_REL24
12379                       && r_type != R_PPC64_REL14
12380                       && r_type != R_PPC64_REL14_BRTAKEN
12381                       && r_type != R_PPC64_REL14_BRNTAKEN)
12382                     continue;
12383
12384                   /* Now determine the call target, its name, value,
12385                      section.  */
12386                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12387                                   r_indx, input_bfd))
12388                     goto error_ret_free_internal;
12389                   hash = (struct ppc_link_hash_entry *) h;
12390
12391                   ok_dest = FALSE;
12392                   fdh = NULL;
12393                   sym_value = 0;
12394                   if (hash == NULL)
12395                     {
12396                       sym_value = sym->st_value;
12397                       if (sym_sec != NULL
12398                           && sym_sec->output_section != NULL)
12399                         ok_dest = TRUE;
12400                     }
12401                   else if (hash->elf.root.type == bfd_link_hash_defined
12402                            || hash->elf.root.type == bfd_link_hash_defweak)
12403                     {
12404                       sym_value = hash->elf.root.u.def.value;
12405                       if (sym_sec->output_section != NULL)
12406                         ok_dest = TRUE;
12407                     }
12408                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12409                            || hash->elf.root.type == bfd_link_hash_undefined)
12410                     {
12411                       /* Recognise an old ABI func code entry sym, and
12412                          use the func descriptor sym instead if it is
12413                          defined.  */
12414                       if (hash->elf.root.root.string[0] == '.'
12415                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12416                         {
12417                           if (fdh->elf.root.type == bfd_link_hash_defined
12418                               || fdh->elf.root.type == bfd_link_hash_defweak)
12419                             {
12420                               sym_sec = fdh->elf.root.u.def.section;
12421                               sym_value = fdh->elf.root.u.def.value;
12422                               if (sym_sec->output_section != NULL)
12423                                 ok_dest = TRUE;
12424                             }
12425                           else
12426                             fdh = NULL;
12427                         }
12428                     }
12429                   else
12430                     {
12431                       bfd_set_error (bfd_error_bad_value);
12432                       goto error_ret_free_internal;
12433                     }
12434
12435                   destination = 0;
12436                   local_off = 0;
12437                   if (ok_dest)
12438                     {
12439                       sym_value += irela->r_addend;
12440                       destination = (sym_value
12441                                      + sym_sec->output_offset
12442                                      + sym_sec->output_section->vma);
12443                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12444                                                             ? hash->elf.other
12445                                                             : sym->st_other);
12446                     }
12447
12448                   code_sec = sym_sec;
12449                   code_value = sym_value;
12450                   opd = get_opd_info (sym_sec);
12451                   if (opd != NULL)
12452                     {
12453                       bfd_vma dest;
12454
12455                       if (hash == NULL && opd->adjust != NULL)
12456                         {
12457                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12458                           if (adjust == -1)
12459                             continue;
12460                           code_value += adjust;
12461                           sym_value += adjust;
12462                         }
12463                       dest = opd_entry_value (sym_sec, sym_value,
12464                                               &code_sec, &code_value, FALSE);
12465                       if (dest != (bfd_vma) -1)
12466                         {
12467                           destination = dest;
12468                           if (fdh != NULL)
12469                             {
12470                               /* Fixup old ABI sym to point at code
12471                                  entry.  */
12472                               hash->elf.root.type = bfd_link_hash_defweak;
12473                               hash->elf.root.u.def.section = code_sec;
12474                               hash->elf.root.u.def.value = code_value;
12475                             }
12476                         }
12477                     }
12478
12479                   /* Determine what (if any) linker stub is needed.  */
12480                   plt_ent = NULL;
12481                   stub_type = ppc_type_of_stub (section, irela, &hash,
12482                                                 &plt_ent, destination,
12483                                                 local_off);
12484
12485                   if (stub_type != ppc_stub_plt_call)
12486                     {
12487                       /* Check whether we need a TOC adjusting stub.
12488                          Since the linker pastes together pieces from
12489                          different object files when creating the
12490                          _init and _fini functions, it may be that a
12491                          call to what looks like a local sym is in
12492                          fact a call needing a TOC adjustment.  */
12493                       if (code_sec != NULL
12494                           && code_sec->output_section != NULL
12495                           && (htab->sec_info[code_sec->id].toc_off
12496                               != htab->sec_info[section->id].toc_off)
12497                           && (code_sec->has_toc_reloc
12498                               || code_sec->makes_toc_func_call))
12499                         stub_type = ppc_stub_long_branch_r2off;
12500                     }
12501
12502                   if (stub_type == ppc_stub_none)
12503                     continue;
12504
12505                   /* __tls_get_addr calls might be eliminated.  */
12506                   if (stub_type != ppc_stub_plt_call
12507                       && hash != NULL
12508                       && (hash == htab->tls_get_addr
12509                           || hash == htab->tls_get_addr_fd)
12510                       && section->has_tls_reloc
12511                       && irela != internal_relocs)
12512                     {
12513                       /* Get tls info.  */
12514                       unsigned char *tls_mask;
12515
12516                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12517                                          irela - 1, input_bfd))
12518                         goto error_ret_free_internal;
12519                       if (*tls_mask != 0)
12520                         continue;
12521                     }
12522
12523                   if (stub_type == ppc_stub_plt_call
12524                       && irela + 1 < irelaend
12525                       && irela[1].r_offset == irela->r_offset + 4
12526                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12527                     {
12528                       if (!tocsave_find (htab, INSERT,
12529                                          &local_syms, irela + 1, input_bfd))
12530                         goto error_ret_free_internal;
12531                     }
12532                   else if (stub_type == ppc_stub_plt_call)
12533                     stub_type = ppc_stub_plt_call_r2save;
12534
12535                   /* Support for grouping stub sections.  */
12536                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12537
12538                   /* Get the name of this stub.  */
12539                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12540                   if (!stub_name)
12541                     goto error_ret_free_internal;
12542
12543                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12544                                                      stub_name, FALSE, FALSE);
12545                   if (stub_entry != NULL)
12546                     {
12547                       /* The proper stub has already been created.  */
12548                       free (stub_name);
12549                       if (stub_type == ppc_stub_plt_call_r2save)
12550                         stub_entry->stub_type = stub_type;
12551                       continue;
12552                     }
12553
12554                   stub_entry = ppc_add_stub (stub_name, section, info);
12555                   if (stub_entry == NULL)
12556                     {
12557                       free (stub_name);
12558                     error_ret_free_internal:
12559                       if (elf_section_data (section)->relocs == NULL)
12560                         free (internal_relocs);
12561                     error_ret_free_local:
12562                       if (local_syms != NULL
12563                           && (symtab_hdr->contents
12564                               != (unsigned char *) local_syms))
12565                         free (local_syms);
12566                       return FALSE;
12567                     }
12568
12569                   stub_entry->stub_type = stub_type;
12570                   if (stub_type != ppc_stub_plt_call
12571                       && stub_type != ppc_stub_plt_call_r2save)
12572                     {
12573                       stub_entry->target_value = code_value;
12574                       stub_entry->target_section = code_sec;
12575                     }
12576                   else
12577                     {
12578                       stub_entry->target_value = sym_value;
12579                       stub_entry->target_section = sym_sec;
12580                     }
12581                   stub_entry->h = hash;
12582                   stub_entry->plt_ent = plt_ent;
12583                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12584
12585                   if (stub_entry->h != NULL)
12586                     htab->stub_globals += 1;
12587                 }
12588
12589               /* We're done with the internal relocs, free them.  */
12590               if (elf_section_data (section)->relocs != internal_relocs)
12591                 free (internal_relocs);
12592             }
12593
12594           if (local_syms != NULL
12595               && symtab_hdr->contents != (unsigned char *) local_syms)
12596             {
12597               if (!info->keep_memory)
12598                 free (local_syms);
12599               else
12600                 symtab_hdr->contents = (unsigned char *) local_syms;
12601             }
12602         }
12603
12604       /* We may have added some stubs.  Find out the new size of the
12605          stub sections.  */
12606       for (stub_sec = htab->params->stub_bfd->sections;
12607            stub_sec != NULL;
12608            stub_sec = stub_sec->next)
12609         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12610           {
12611             if (htab->stub_iteration <= STUB_SHRINK_ITER
12612                 || stub_sec->rawsize < stub_sec->size)
12613               /* Past STUB_SHRINK_ITER, rawsize is the max size seen.  */
12614               stub_sec->rawsize = stub_sec->size;
12615             stub_sec->size = 0;
12616             stub_sec->reloc_count = 0;
12617             stub_sec->flags &= ~SEC_RELOC;
12618           }
12619
12620       htab->brlt->size = 0;
12621       htab->brlt->reloc_count = 0;
12622       htab->brlt->flags &= ~SEC_RELOC;
12623       if (htab->relbrlt != NULL)
12624         htab->relbrlt->size = 0;
12625
12626       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12627
12628       for (group = htab->group; group != NULL; group = group->next)
12629         if (group->needs_save_res)
12630           group->stub_sec->size += htab->sfpr->size;
12631
12632       if (info->emitrelocations
12633           && htab->glink != NULL && htab->glink->size != 0)
12634         {
12635           htab->glink->reloc_count = 1;
12636           htab->glink->flags |= SEC_RELOC;
12637         }
12638
12639       if (htab->glink_eh_frame != NULL
12640           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12641           && htab->glink_eh_frame->output_section->size != 0)
12642         {
12643           size_t size = 0, align;
12644
12645           for (stub_sec = htab->params->stub_bfd->sections;
12646                stub_sec != NULL;
12647                stub_sec = stub_sec->next)
12648             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12649               size += 24;
12650           if (htab->glink != NULL && htab->glink->size != 0)
12651             size += 24;
12652           if (size != 0)
12653             size += sizeof (glink_eh_frame_cie);
12654           align = 1;
12655           align <<= htab->glink_eh_frame->output_section->alignment_power;
12656           align -= 1;
12657           size = (size + align) & ~align;
12658           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12659           htab->glink_eh_frame->size = size;
12660         }
12661
12662       if (htab->params->plt_stub_align != 0)
12663         for (stub_sec = htab->params->stub_bfd->sections;
12664              stub_sec != NULL;
12665              stub_sec = stub_sec->next)
12666           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12667             stub_sec->size = ((stub_sec->size
12668                                + (1 << htab->params->plt_stub_align) - 1)
12669                               & -(1 << htab->params->plt_stub_align));
12670
12671       for (stub_sec = htab->params->stub_bfd->sections;
12672            stub_sec != NULL;
12673            stub_sec = stub_sec->next)
12674         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12675             && stub_sec->rawsize != stub_sec->size
12676             && (htab->stub_iteration <= STUB_SHRINK_ITER
12677                 || stub_sec->rawsize < stub_sec->size))
12678           break;
12679
12680       if (stub_sec == NULL
12681           && (htab->glink_eh_frame == NULL
12682               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12683         break;
12684
12685       /* Ask the linker to do its stuff.  */
12686       (*htab->params->layout_sections_again) ();
12687     }
12688
12689   if (htab->glink_eh_frame != NULL
12690       && htab->glink_eh_frame->size != 0)
12691     {
12692       bfd_vma val;
12693       bfd_byte *p, *last_fde;
12694       size_t last_fde_len, size, align, pad;
12695       asection *stub_sec;
12696
12697       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12698       if (p == NULL)
12699         return FALSE;
12700       htab->glink_eh_frame->contents = p;
12701       last_fde = p;
12702
12703       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12704       /* CIE length (rewrite in case little-endian).  */
12705       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12706       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12707       p += sizeof (glink_eh_frame_cie);
12708
12709       for (stub_sec = htab->params->stub_bfd->sections;
12710            stub_sec != NULL;
12711            stub_sec = stub_sec->next)
12712         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12713           {
12714             last_fde = p;
12715             last_fde_len = 20;
12716             /* FDE length.  */
12717             bfd_put_32 (htab->elf.dynobj, 20, p);
12718             p += 4;
12719             /* CIE pointer.  */
12720             val = p - htab->glink_eh_frame->contents;
12721             bfd_put_32 (htab->elf.dynobj, val, p);
12722             p += 4;
12723             /* Offset to stub section, written later.  */
12724             p += 4;
12725             /* stub section size.  */
12726             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12727             p += 4;
12728             /* Augmentation.  */
12729             p += 1;
12730             /* Pad.  */
12731             p += 7;
12732           }
12733       if (htab->glink != NULL && htab->glink->size != 0)
12734         {
12735           last_fde = p;
12736           last_fde_len = 20;
12737           /* FDE length.  */
12738           bfd_put_32 (htab->elf.dynobj, 20, p);
12739           p += 4;
12740           /* CIE pointer.  */
12741           val = p - htab->glink_eh_frame->contents;
12742           bfd_put_32 (htab->elf.dynobj, val, p);
12743           p += 4;
12744           /* Offset to .glink, written later.  */
12745           p += 4;
12746           /* .glink size.  */
12747           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12748           p += 4;
12749           /* Augmentation.  */
12750           p += 1;
12751
12752           *p++ = DW_CFA_advance_loc + 1;
12753           *p++ = DW_CFA_register;
12754           *p++ = 65;
12755           *p++ = htab->opd_abi ? 12 : 0;
12756           *p++ = DW_CFA_advance_loc + 4;
12757           *p++ = DW_CFA_restore_extended;
12758           *p++ = 65;
12759         }
12760       /* Subsume any padding into the last FDE if user .eh_frame
12761          sections are aligned more than glink_eh_frame.  Otherwise any
12762          zero padding will be seen as a terminator.  */
12763       size = p - htab->glink_eh_frame->contents;
12764       align = 1;
12765       align <<= htab->glink_eh_frame->output_section->alignment_power;
12766       align -= 1;
12767       pad = ((size + align) & ~align) - size;
12768       htab->glink_eh_frame->size = size + pad;
12769       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12770     }
12771
12772   maybe_strip_output (info, htab->brlt);
12773   if (htab->glink_eh_frame != NULL)
12774     maybe_strip_output (info, htab->glink_eh_frame);
12775
12776   return TRUE;
12777 }
12778
12779 /* Called after we have determined section placement.  If sections
12780    move, we'll be called again.  Provide a value for TOCstart.  */
12781
12782 bfd_vma
12783 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12784 {
12785   asection *s;
12786   bfd_vma TOCstart, adjust;
12787
12788   if (info != NULL)
12789     {
12790       struct elf_link_hash_entry *h;
12791       struct elf_link_hash_table *htab = elf_hash_table (info);
12792
12793       if (is_elf_hash_table (htab)
12794           && htab->hgot != NULL)
12795         h = htab->hgot;
12796       else
12797         {
12798           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12799           if (is_elf_hash_table (htab))
12800             htab->hgot = h;
12801         }
12802       if (h != NULL
12803           && h->root.type == bfd_link_hash_defined
12804           && !h->root.linker_def
12805           && (!is_elf_hash_table (htab)
12806               || h->def_regular))
12807         {
12808           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12809                       + h->root.u.def.section->output_offset
12810                       + h->root.u.def.section->output_section->vma);
12811           _bfd_set_gp_value (obfd, TOCstart);
12812           return TOCstart;
12813         }
12814     }
12815
12816   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12817      order.  The TOC starts where the first of these sections starts.  */
12818   s = bfd_get_section_by_name (obfd, ".got");
12819   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12820     s = bfd_get_section_by_name (obfd, ".toc");
12821   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12822     s = bfd_get_section_by_name (obfd, ".tocbss");
12823   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12824     s = bfd_get_section_by_name (obfd, ".plt");
12825   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12826     {
12827       /* This may happen for
12828          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12829          .toc directive
12830          o  bad linker script
12831          o --gc-sections and empty TOC sections
12832
12833          FIXME: Warn user?  */
12834
12835       /* Look for a likely section.  We probably won't even be
12836          using TOCstart.  */
12837       for (s = obfd->sections; s != NULL; s = s->next)
12838         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12839                          | SEC_EXCLUDE))
12840             == (SEC_ALLOC | SEC_SMALL_DATA))
12841           break;
12842       if (s == NULL)
12843         for (s = obfd->sections; s != NULL; s = s->next)
12844           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12845               == (SEC_ALLOC | SEC_SMALL_DATA))
12846             break;
12847       if (s == NULL)
12848         for (s = obfd->sections; s != NULL; s = s->next)
12849           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12850               == SEC_ALLOC)
12851             break;
12852       if (s == NULL)
12853         for (s = obfd->sections; s != NULL; s = s->next)
12854           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12855             break;
12856     }
12857
12858   TOCstart = 0;
12859   if (s != NULL)
12860     TOCstart = s->output_section->vma + s->output_offset;
12861
12862   /* Force alignment.  */
12863   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12864   TOCstart -= adjust;
12865   _bfd_set_gp_value (obfd, TOCstart);
12866
12867   if (info != NULL && s != NULL)
12868     {
12869       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12870
12871       if (htab != NULL)
12872         {
12873           if (htab->elf.hgot != NULL)
12874             {
12875               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12876               htab->elf.hgot->root.u.def.section = s;
12877             }
12878         }
12879       else
12880         {
12881           struct bfd_link_hash_entry *bh = NULL;
12882           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12883                                             s, TOC_BASE_OFF - adjust,
12884                                             NULL, FALSE, FALSE, &bh);
12885         }
12886     }
12887   return TOCstart;
12888 }
12889
12890 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12891    write out any global entry stubs.  */
12892
12893 static bfd_boolean
12894 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12895 {
12896   struct bfd_link_info *info;
12897   struct ppc_link_hash_table *htab;
12898   struct plt_entry *pent;
12899   asection *s;
12900
12901   if (h->root.type == bfd_link_hash_indirect)
12902     return TRUE;
12903
12904   if (!h->pointer_equality_needed)
12905     return TRUE;
12906
12907   if (h->def_regular)
12908     return TRUE;
12909
12910   info = inf;
12911   htab = ppc_hash_table (info);
12912   if (htab == NULL)
12913     return FALSE;
12914
12915   s = htab->glink;
12916   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12917     if (pent->plt.offset != (bfd_vma) -1
12918         && pent->addend == 0)
12919       {
12920         bfd_byte *p;
12921         asection *plt;
12922         bfd_vma off;
12923
12924         p = s->contents + h->root.u.def.value;
12925         plt = htab->elf.splt;
12926         if (!htab->elf.dynamic_sections_created
12927             || h->dynindx == -1)
12928           plt = htab->elf.iplt;
12929         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12930         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12931
12932         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12933           {
12934             info->callbacks->einfo
12935               (_("%P: linkage table error against `%T'\n"),
12936                h->root.root.string);
12937             bfd_set_error (bfd_error_bad_value);
12938             htab->stub_error = TRUE;
12939           }
12940
12941         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12942         if (htab->params->emit_stub_syms)
12943           {
12944             size_t len = strlen (h->root.root.string);
12945             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12946
12947             if (name == NULL)
12948               return FALSE;
12949
12950             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12951             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12952             if (h == NULL)
12953               return FALSE;
12954             if (h->root.type == bfd_link_hash_new)
12955               {
12956                 h->root.type = bfd_link_hash_defined;
12957                 h->root.u.def.section = s;
12958                 h->root.u.def.value = p - s->contents;
12959                 h->ref_regular = 1;
12960                 h->def_regular = 1;
12961                 h->ref_regular_nonweak = 1;
12962                 h->forced_local = 1;
12963                 h->non_elf = 0;
12964                 h->root.linker_def = 1;
12965               }
12966           }
12967
12968         if (PPC_HA (off) != 0)
12969           {
12970             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12971             p += 4;
12972           }
12973         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12974         p += 4;
12975         bfd_put_32 (s->owner, MTCTR_R12, p);
12976         p += 4;
12977         bfd_put_32 (s->owner, BCTR, p);
12978         break;
12979       }
12980   return TRUE;
12981 }
12982
12983 /* Build all the stubs associated with the current output file.
12984    The stubs are kept in a hash table attached to the main linker
12985    hash table.  This function is called via gldelf64ppc_finish.  */
12986
12987 bfd_boolean
12988 ppc64_elf_build_stubs (struct bfd_link_info *info,
12989                        char **stats)
12990 {
12991   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12992   struct map_stub *group;
12993   asection *stub_sec;
12994   bfd_byte *p;
12995   int stub_sec_count = 0;
12996
12997   if (htab == NULL)
12998     return FALSE;
12999
13000   /* Allocate memory to hold the linker stubs.  */
13001   for (stub_sec = htab->params->stub_bfd->sections;
13002        stub_sec != NULL;
13003        stub_sec = stub_sec->next)
13004     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13005         && stub_sec->size != 0)
13006       {
13007         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13008         if (stub_sec->contents == NULL)
13009           return FALSE;
13010         stub_sec->size = 0;
13011       }
13012
13013   if (htab->glink != NULL && htab->glink->size != 0)
13014     {
13015       unsigned int indx;
13016       bfd_vma plt0;
13017
13018       /* Build the .glink plt call stub.  */
13019       if (htab->params->emit_stub_syms)
13020         {
13021           struct elf_link_hash_entry *h;
13022           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13023                                     TRUE, FALSE, FALSE);
13024           if (h == NULL)
13025             return FALSE;
13026           if (h->root.type == bfd_link_hash_new)
13027             {
13028               h->root.type = bfd_link_hash_defined;
13029               h->root.u.def.section = htab->glink;
13030               h->root.u.def.value = 8;
13031               h->ref_regular = 1;
13032               h->def_regular = 1;
13033               h->ref_regular_nonweak = 1;
13034               h->forced_local = 1;
13035               h->non_elf = 0;
13036               h->root.linker_def = 1;
13037             }
13038         }
13039       plt0 = (htab->elf.splt->output_section->vma
13040               + htab->elf.splt->output_offset
13041               - 16);
13042       if (info->emitrelocations)
13043         {
13044           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13045           if (r == NULL)
13046             return FALSE;
13047           r->r_offset = (htab->glink->output_offset
13048                          + htab->glink->output_section->vma);
13049           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13050           r->r_addend = plt0;
13051         }
13052       p = htab->glink->contents;
13053       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13054       bfd_put_64 (htab->glink->owner, plt0, p);
13055       p += 8;
13056       if (htab->opd_abi)
13057         {
13058           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13059           p += 4;
13060           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13061           p += 4;
13062           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13063           p += 4;
13064           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13065           p += 4;
13066           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13067           p += 4;
13068           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13069           p += 4;
13070           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13071           p += 4;
13072           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13073           p += 4;
13074           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13075           p += 4;
13076           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13077           p += 4;
13078         }
13079       else
13080         {
13081           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13082           p += 4;
13083           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13084           p += 4;
13085           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13086           p += 4;
13087           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13088           p += 4;
13089           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13090           p += 4;
13091           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13092           p += 4;
13093           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13094           p += 4;
13095           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13096           p += 4;
13097           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13098           p += 4;
13099           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13100           p += 4;
13101           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13102           p += 4;
13103           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13104           p += 4;
13105         }
13106       bfd_put_32 (htab->glink->owner, BCTR, p);
13107       p += 4;
13108       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13109         {
13110           bfd_put_32 (htab->glink->owner, NOP, p);
13111           p += 4;
13112         }
13113
13114       /* Build the .glink lazy link call stubs.  */
13115       indx = 0;
13116       while (p < htab->glink->contents + htab->glink->rawsize)
13117         {
13118           if (htab->opd_abi)
13119             {
13120               if (indx < 0x8000)
13121                 {
13122                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13123                   p += 4;
13124                 }
13125               else
13126                 {
13127                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13128                   p += 4;
13129                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13130                               p);
13131                   p += 4;
13132                 }
13133             }
13134           bfd_put_32 (htab->glink->owner,
13135                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13136           indx++;
13137           p += 4;
13138         }
13139
13140       /* Build .glink global entry stubs.  */
13141       if (htab->glink->size > htab->glink->rawsize)
13142         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13143     }
13144
13145   if (htab->brlt != NULL && htab->brlt->size != 0)
13146     {
13147       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13148                                          htab->brlt->size);
13149       if (htab->brlt->contents == NULL)
13150         return FALSE;
13151     }
13152   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13153     {
13154       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13155                                             htab->relbrlt->size);
13156       if (htab->relbrlt->contents == NULL)
13157         return FALSE;
13158     }
13159
13160   /* Build the stubs as directed by the stub hash table.  */
13161   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13162
13163   for (group = htab->group; group != NULL; group = group->next)
13164     if (group->needs_save_res)
13165       {
13166         stub_sec = group->stub_sec;
13167         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13168                 htab->sfpr->size);
13169         if (htab->params->emit_stub_syms)
13170           {
13171             unsigned int i;
13172
13173             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13174               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13175                 return FALSE;
13176           }
13177         stub_sec->size += htab->sfpr->size;
13178       }
13179
13180   if (htab->relbrlt != NULL)
13181     htab->relbrlt->reloc_count = 0;
13182
13183   if (htab->params->plt_stub_align != 0)
13184     for (stub_sec = htab->params->stub_bfd->sections;
13185          stub_sec != NULL;
13186          stub_sec = stub_sec->next)
13187       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13188         stub_sec->size = ((stub_sec->size
13189                            + (1 << htab->params->plt_stub_align) - 1)
13190                           & -(1 << htab->params->plt_stub_align));
13191
13192   for (stub_sec = htab->params->stub_bfd->sections;
13193        stub_sec != NULL;
13194        stub_sec = stub_sec->next)
13195     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13196       {
13197         stub_sec_count += 1;
13198         if (stub_sec->rawsize != stub_sec->size
13199             && (htab->stub_iteration <= STUB_SHRINK_ITER
13200                 || stub_sec->rawsize < stub_sec->size))
13201           break;
13202       }
13203
13204   /* Note that the glink_eh_frame check here is not only testing that
13205      the generated size matched the calculated size but also that
13206      bfd_elf_discard_info didn't make any changes to the section.  */
13207   if (stub_sec != NULL
13208       || (htab->glink_eh_frame != NULL
13209           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13210     {
13211       htab->stub_error = TRUE;
13212       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13213     }
13214
13215   if (htab->stub_error)
13216     return FALSE;
13217
13218   if (stats != NULL)
13219     {
13220       *stats = bfd_malloc (500);
13221       if (*stats == NULL)
13222         return FALSE;
13223
13224       sprintf (*stats, _("linker stubs in %u group%s\n"
13225                          "  branch       %lu\n"
13226                          "  toc adjust   %lu\n"
13227                          "  long branch  %lu\n"
13228                          "  long toc adj %lu\n"
13229                          "  plt call     %lu\n"
13230                          "  plt call toc %lu\n"
13231                          "  global entry %lu"),
13232                stub_sec_count,
13233                stub_sec_count == 1 ? "" : "s",
13234                htab->stub_count[ppc_stub_long_branch - 1],
13235                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13236                htab->stub_count[ppc_stub_plt_branch - 1],
13237                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13238                htab->stub_count[ppc_stub_plt_call - 1],
13239                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13240                htab->stub_count[ppc_stub_global_entry - 1]);
13241     }
13242   return TRUE;
13243 }
13244
13245 /* This function undoes the changes made by add_symbol_adjust.  */
13246
13247 static bfd_boolean
13248 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13249 {
13250   struct ppc_link_hash_entry *eh;
13251
13252   if (h->root.type == bfd_link_hash_indirect)
13253     return TRUE;
13254
13255   eh = (struct ppc_link_hash_entry *) h;
13256   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13257     return TRUE;
13258
13259   eh->elf.root.type = bfd_link_hash_undefined;
13260   return TRUE;
13261 }
13262
13263 void
13264 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13265 {
13266   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13267
13268   if (htab != NULL)
13269     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13270 }
13271
13272 /* What to do when ld finds relocations against symbols defined in
13273    discarded sections.  */
13274
13275 static unsigned int
13276 ppc64_elf_action_discarded (asection *sec)
13277 {
13278   if (strcmp (".opd", sec->name) == 0)
13279     return 0;
13280
13281   if (strcmp (".toc", sec->name) == 0)
13282     return 0;
13283
13284   if (strcmp (".toc1", sec->name) == 0)
13285     return 0;
13286
13287   return _bfd_elf_default_action_discarded (sec);
13288 }
13289
13290 /* The RELOCATE_SECTION function is called by the ELF backend linker
13291    to handle the relocations for a section.
13292
13293    The relocs are always passed as Rela structures; if the section
13294    actually uses Rel structures, the r_addend field will always be
13295    zero.
13296
13297    This function is responsible for adjust the section contents as
13298    necessary, and (if using Rela relocs and generating a
13299    relocatable output file) adjusting the reloc addend as
13300    necessary.
13301
13302    This function does not have to worry about setting the reloc
13303    address or the reloc symbol index.
13304
13305    LOCAL_SYMS is a pointer to the swapped in local symbols.
13306
13307    LOCAL_SECTIONS is an array giving the section in the input file
13308    corresponding to the st_shndx field of each local symbol.
13309
13310    The global hash table entry for the global symbols can be found
13311    via elf_sym_hashes (input_bfd).
13312
13313    When generating relocatable output, this function must handle
13314    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13315    going to be the section symbol corresponding to the output
13316    section, which means that the addend must be adjusted
13317    accordingly.  */
13318
13319 static bfd_boolean
13320 ppc64_elf_relocate_section (bfd *output_bfd,
13321                             struct bfd_link_info *info,
13322                             bfd *input_bfd,
13323                             asection *input_section,
13324                             bfd_byte *contents,
13325                             Elf_Internal_Rela *relocs,
13326                             Elf_Internal_Sym *local_syms,
13327                             asection **local_sections)
13328 {
13329   struct ppc_link_hash_table *htab;
13330   Elf_Internal_Shdr *symtab_hdr;
13331   struct elf_link_hash_entry **sym_hashes;
13332   Elf_Internal_Rela *rel;
13333   Elf_Internal_Rela *wrel;
13334   Elf_Internal_Rela *relend;
13335   Elf_Internal_Rela outrel;
13336   bfd_byte *loc;
13337   struct got_entry **local_got_ents;
13338   bfd_vma TOCstart;
13339   bfd_boolean ret = TRUE;
13340   bfd_boolean is_opd;
13341   /* Assume 'at' branch hints.  */
13342   bfd_boolean is_isa_v2 = TRUE;
13343   bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13344
13345   /* Initialize howto table if needed.  */
13346   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13347     ppc_howto_init ();
13348
13349   htab = ppc_hash_table (info);
13350   if (htab == NULL)
13351     return FALSE;
13352
13353   /* Don't relocate stub sections.  */
13354   if (input_section->owner == htab->params->stub_bfd)
13355     return TRUE;
13356
13357   BFD_ASSERT (is_ppc64_elf (input_bfd));
13358
13359   local_got_ents = elf_local_got_ents (input_bfd);
13360   TOCstart = elf_gp (output_bfd);
13361   symtab_hdr = &elf_symtab_hdr (input_bfd);
13362   sym_hashes = elf_sym_hashes (input_bfd);
13363   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13364
13365   rel = wrel = relocs;
13366   relend = relocs + input_section->reloc_count;
13367   for (; rel < relend; wrel++, rel++)
13368     {
13369       enum elf_ppc64_reloc_type r_type;
13370       bfd_vma addend;
13371       bfd_reloc_status_type r;
13372       Elf_Internal_Sym *sym;
13373       asection *sec;
13374       struct elf_link_hash_entry *h_elf;
13375       struct ppc_link_hash_entry *h;
13376       struct ppc_link_hash_entry *fdh;
13377       const char *sym_name;
13378       unsigned long r_symndx, toc_symndx;
13379       bfd_vma toc_addend;
13380       unsigned char tls_mask, tls_gd, tls_type;
13381       unsigned char sym_type;
13382       bfd_vma relocation;
13383       bfd_boolean unresolved_reloc;
13384       bfd_boolean warned;
13385       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13386       unsigned int insn;
13387       unsigned int mask;
13388       struct ppc_stub_hash_entry *stub_entry;
13389       bfd_vma max_br_offset;
13390       bfd_vma from;
13391       Elf_Internal_Rela orig_rel;
13392       reloc_howto_type *howto;
13393       struct reloc_howto_struct alt_howto;
13394
13395     again:
13396       orig_rel = *rel;
13397
13398       r_type = ELF64_R_TYPE (rel->r_info);
13399       r_symndx = ELF64_R_SYM (rel->r_info);
13400
13401       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13402          symbol of the previous ADDR64 reloc.  The symbol gives us the
13403          proper TOC base to use.  */
13404       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13405           && wrel != relocs
13406           && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13407           && is_opd)
13408         r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13409
13410       sym = NULL;
13411       sec = NULL;
13412       h_elf = NULL;
13413       sym_name = NULL;
13414       unresolved_reloc = FALSE;
13415       warned = FALSE;
13416
13417       if (r_symndx < symtab_hdr->sh_info)
13418         {
13419           /* It's a local symbol.  */
13420           struct _opd_sec_data *opd;
13421
13422           sym = local_syms + r_symndx;
13423           sec = local_sections[r_symndx];
13424           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13425           sym_type = ELF64_ST_TYPE (sym->st_info);
13426           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13427           opd = get_opd_info (sec);
13428           if (opd != NULL && opd->adjust != NULL)
13429             {
13430               long adjust = opd->adjust[OPD_NDX (sym->st_value
13431                                                  + rel->r_addend)];
13432               if (adjust == -1)
13433                 relocation = 0;
13434               else
13435                 {
13436                   /* If this is a relocation against the opd section sym
13437                      and we have edited .opd, adjust the reloc addend so
13438                      that ld -r and ld --emit-relocs output is correct.
13439                      If it is a reloc against some other .opd symbol,
13440                      then the symbol value will be adjusted later.  */
13441                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13442                     rel->r_addend += adjust;
13443                   else
13444                     relocation += adjust;
13445                 }
13446             }
13447         }
13448       else
13449         {
13450           bfd_boolean ignored;
13451
13452           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13453                                    r_symndx, symtab_hdr, sym_hashes,
13454                                    h_elf, sec, relocation,
13455                                    unresolved_reloc, warned, ignored);
13456           sym_name = h_elf->root.root.string;
13457           sym_type = h_elf->type;
13458           if (sec != NULL
13459               && sec->owner == output_bfd
13460               && strcmp (sec->name, ".opd") == 0)
13461             {
13462               /* This is a symbol defined in a linker script.  All
13463                  such are defined in output sections, even those
13464                  defined by simple assignment from a symbol defined in
13465                  an input section.  Transfer the symbol to an
13466                  appropriate input .opd section, so that a branch to
13467                  this symbol will be mapped to the location specified
13468                  by the opd entry.  */
13469               struct bfd_link_order *lo;
13470               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13471                 if (lo->type == bfd_indirect_link_order)
13472                   {
13473                     asection *isec = lo->u.indirect.section;
13474                     if (h_elf->root.u.def.value >= isec->output_offset
13475                         && h_elf->root.u.def.value < (isec->output_offset
13476                                                       + isec->size))
13477                       {
13478                         h_elf->root.u.def.value -= isec->output_offset;
13479                         h_elf->root.u.def.section = isec;
13480                         sec = isec;
13481                         break;
13482                       }
13483                   }
13484             }
13485         }
13486       h = (struct ppc_link_hash_entry *) h_elf;
13487
13488       if (sec != NULL && discarded_section (sec))
13489         {
13490           _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13491                                input_bfd, input_section,
13492                                contents + rel->r_offset);
13493           wrel->r_offset = rel->r_offset;
13494           wrel->r_info = 0;
13495           wrel->r_addend = 0;
13496
13497           /* For ld -r, remove relocations in debug sections against
13498              sections defined in discarded sections.  Not done for
13499              non-debug to preserve relocs in .eh_frame which the
13500              eh_frame editing code expects to be present.  */
13501           if (bfd_link_relocatable (info)
13502               && (input_section->flags & SEC_DEBUGGING))
13503             wrel--;
13504
13505           continue;
13506         }
13507
13508       if (bfd_link_relocatable (info))
13509         goto copy_reloc;
13510
13511       if (h != NULL && &h->elf == htab->elf.hgot)
13512         {
13513           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13514           sec = bfd_abs_section_ptr;
13515           unresolved_reloc = FALSE;
13516         }
13517
13518       /* TLS optimizations.  Replace instruction sequences and relocs
13519          based on information we collected in tls_optimize.  We edit
13520          RELOCS so that --emit-relocs will output something sensible
13521          for the final instruction stream.  */
13522       tls_mask = 0;
13523       tls_gd = 0;
13524       toc_symndx = 0;
13525       if (h != NULL)
13526         tls_mask = h->tls_mask;
13527       else if (local_got_ents != NULL)
13528         {
13529           struct plt_entry **local_plt = (struct plt_entry **)
13530             (local_got_ents + symtab_hdr->sh_info);
13531           unsigned char *lgot_masks = (unsigned char *)
13532             (local_plt + symtab_hdr->sh_info);
13533           tls_mask = lgot_masks[r_symndx];
13534         }
13535       if (tls_mask == 0
13536           && (r_type == R_PPC64_TLS
13537               || r_type == R_PPC64_TLSGD
13538               || r_type == R_PPC64_TLSLD))
13539         {
13540           /* Check for toc tls entries.  */
13541           unsigned char *toc_tls;
13542
13543           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13544                              &local_syms, rel, input_bfd))
13545             return FALSE;
13546
13547           if (toc_tls)
13548             tls_mask = *toc_tls;
13549         }
13550
13551       /* Check that tls relocs are used with tls syms, and non-tls
13552          relocs are used with non-tls syms.  */
13553       if (r_symndx != STN_UNDEF
13554           && r_type != R_PPC64_NONE
13555           && (h == NULL
13556               || h->elf.root.type == bfd_link_hash_defined
13557               || h->elf.root.type == bfd_link_hash_defweak)
13558           && (IS_PPC64_TLS_RELOC (r_type)
13559               != (sym_type == STT_TLS
13560                   || (sym_type == STT_SECTION
13561                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13562         {
13563           if (tls_mask != 0
13564               && (r_type == R_PPC64_TLS
13565                   || r_type == R_PPC64_TLSGD
13566                   || r_type == R_PPC64_TLSLD))
13567             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13568             ;
13569           else
13570             info->callbacks->einfo
13571               (!IS_PPC64_TLS_RELOC (r_type)
13572                /* xgettext:c-format */
13573                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13574                /* xgettext:c-format */
13575                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13576                input_bfd, input_section, rel->r_offset,
13577                ppc64_elf_howto_table[r_type]->name,
13578                sym_name);
13579         }
13580
13581       /* Ensure reloc mapping code below stays sane.  */
13582       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13583           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13584           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13585           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13586           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13587           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13588           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13589           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13590           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13591           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13592         abort ();
13593
13594       switch (r_type)
13595         {
13596         default:
13597           break;
13598
13599         case R_PPC64_LO_DS_OPT:
13600           insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13601           if ((insn & (0x3f << 26)) != 58u << 26)
13602             abort ();
13603           insn += (14u << 26) - (58u << 26);
13604           bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13605           r_type = R_PPC64_TOC16_LO;
13606           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13607           break;
13608
13609         case R_PPC64_TOC16:
13610         case R_PPC64_TOC16_LO:
13611         case R_PPC64_TOC16_DS:
13612         case R_PPC64_TOC16_LO_DS:
13613           {
13614             /* Check for toc tls entries.  */
13615             unsigned char *toc_tls;
13616             int retval;
13617
13618             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13619                                    &local_syms, rel, input_bfd);
13620             if (retval == 0)
13621               return FALSE;
13622
13623             if (toc_tls)
13624               {
13625                 tls_mask = *toc_tls;
13626                 if (r_type == R_PPC64_TOC16_DS
13627                     || r_type == R_PPC64_TOC16_LO_DS)
13628                   {
13629                     if (tls_mask != 0
13630                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13631                       goto toctprel;
13632                   }
13633                 else
13634                   {
13635                     /* If we found a GD reloc pair, then we might be
13636                        doing a GD->IE transition.  */
13637                     if (retval == 2)
13638                       {
13639                         tls_gd = TLS_TPRELGD;
13640                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13641                           goto tls_ldgd_opt;
13642                       }
13643                     else if (retval == 3)
13644                       {
13645                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13646                           goto tls_ldgd_opt;
13647                       }
13648                   }
13649               }
13650           }
13651           break;
13652
13653         case R_PPC64_GOT_TPREL16_HI:
13654         case R_PPC64_GOT_TPREL16_HA:
13655           if (tls_mask != 0
13656               && (tls_mask & TLS_TPREL) == 0)
13657             {
13658               rel->r_offset -= d_offset;
13659               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13660               r_type = R_PPC64_NONE;
13661               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13662             }
13663           break;
13664
13665         case R_PPC64_GOT_TPREL16_DS:
13666         case R_PPC64_GOT_TPREL16_LO_DS:
13667           if (tls_mask != 0
13668               && (tls_mask & TLS_TPREL) == 0)
13669             {
13670             toctprel:
13671               insn = bfd_get_32 (input_bfd,
13672                                  contents + rel->r_offset - d_offset);
13673               insn &= 31 << 21;
13674               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13675               bfd_put_32 (input_bfd, insn,
13676                           contents + rel->r_offset - d_offset);
13677               r_type = R_PPC64_TPREL16_HA;
13678               if (toc_symndx != 0)
13679                 {
13680                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13681                   rel->r_addend = toc_addend;
13682                   /* We changed the symbol.  Start over in order to
13683                      get h, sym, sec etc. right.  */
13684                   goto again;
13685                 }
13686               else
13687                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13688             }
13689           break;
13690
13691         case R_PPC64_TLS:
13692           if (tls_mask != 0
13693               && (tls_mask & TLS_TPREL) == 0)
13694             {
13695               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13696               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13697               if (insn == 0)
13698                 abort ();
13699               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13700               /* Was PPC64_TLS which sits on insn boundary, now
13701                  PPC64_TPREL16_LO which is at low-order half-word.  */
13702               rel->r_offset += d_offset;
13703               r_type = R_PPC64_TPREL16_LO;
13704               if (toc_symndx != 0)
13705                 {
13706                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13707                   rel->r_addend = toc_addend;
13708                   /* We changed the symbol.  Start over in order to
13709                      get h, sym, sec etc. right.  */
13710                   goto again;
13711                 }
13712               else
13713                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13714             }
13715           break;
13716
13717         case R_PPC64_GOT_TLSGD16_HI:
13718         case R_PPC64_GOT_TLSGD16_HA:
13719           tls_gd = TLS_TPRELGD;
13720           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13721             goto tls_gdld_hi;
13722           break;
13723
13724         case R_PPC64_GOT_TLSLD16_HI:
13725         case R_PPC64_GOT_TLSLD16_HA:
13726           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13727             {
13728             tls_gdld_hi:
13729               if ((tls_mask & tls_gd) != 0)
13730                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13731                           + R_PPC64_GOT_TPREL16_DS);
13732               else
13733                 {
13734                   rel->r_offset -= d_offset;
13735                   bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13736                   r_type = R_PPC64_NONE;
13737                 }
13738               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13739             }
13740           break;
13741
13742         case R_PPC64_GOT_TLSGD16:
13743         case R_PPC64_GOT_TLSGD16_LO:
13744           tls_gd = TLS_TPRELGD;
13745           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13746             goto tls_ldgd_opt;
13747           break;
13748
13749         case R_PPC64_GOT_TLSLD16:
13750         case R_PPC64_GOT_TLSLD16_LO:
13751           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13752             {
13753               unsigned int insn1, insn2, insn3;
13754               bfd_vma offset;
13755
13756             tls_ldgd_opt:
13757               offset = (bfd_vma) -1;
13758               /* If not using the newer R_PPC64_TLSGD/LD to mark
13759                  __tls_get_addr calls, we must trust that the call
13760                  stays with its arg setup insns, ie. that the next
13761                  reloc is the __tls_get_addr call associated with
13762                  the current reloc.  Edit both insns.  */
13763               if (input_section->has_tls_get_addr_call
13764                   && rel + 1 < relend
13765                   && branch_reloc_hash_match (input_bfd, rel + 1,
13766                                               htab->tls_get_addr,
13767                                               htab->tls_get_addr_fd))
13768                 offset = rel[1].r_offset;
13769               /* We read the low GOT_TLS (or TOC16) insn because we
13770                  need to keep the destination reg.  It may be
13771                  something other than the usual r3, and moved to r3
13772                  before the call by intervening code.  */
13773               insn1 = bfd_get_32 (input_bfd,
13774                                   contents + rel->r_offset - d_offset);
13775               if ((tls_mask & tls_gd) != 0)
13776                 {
13777                   /* IE */
13778                   insn1 &= (0x1f << 21) | (0x1f << 16);
13779                   insn1 |= 58 << 26;    /* ld */
13780                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13781                   if (offset != (bfd_vma) -1)
13782                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13783                   if ((tls_mask & TLS_EXPLICIT) == 0)
13784                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13785                               + R_PPC64_GOT_TPREL16_DS);
13786                   else
13787                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13788                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13789                 }
13790               else
13791                 {
13792                   /* LE */
13793                   insn1 &= 0x1f << 21;
13794                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13795                   insn2 = 0x38630000;   /* addi 3,3,0 */
13796                   if (tls_gd == 0)
13797                     {
13798                       /* Was an LD reloc.  */
13799                       if (toc_symndx)
13800                         sec = local_sections[toc_symndx];
13801                       for (r_symndx = 0;
13802                            r_symndx < symtab_hdr->sh_info;
13803                            r_symndx++)
13804                         if (local_sections[r_symndx] == sec)
13805                           break;
13806                       if (r_symndx >= symtab_hdr->sh_info)
13807                         r_symndx = STN_UNDEF;
13808                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13809                       if (r_symndx != STN_UNDEF)
13810                         rel->r_addend -= (local_syms[r_symndx].st_value
13811                                           + sec->output_offset
13812                                           + sec->output_section->vma);
13813                     }
13814                   else if (toc_symndx != 0)
13815                     {
13816                       r_symndx = toc_symndx;
13817                       rel->r_addend = toc_addend;
13818                     }
13819                   r_type = R_PPC64_TPREL16_HA;
13820                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13821                   if (offset != (bfd_vma) -1)
13822                     {
13823                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13824                                                     R_PPC64_TPREL16_LO);
13825                       rel[1].r_offset = offset + d_offset;
13826                       rel[1].r_addend = rel->r_addend;
13827                     }
13828                 }
13829               bfd_put_32 (input_bfd, insn1,
13830                           contents + rel->r_offset - d_offset);
13831               if (offset != (bfd_vma) -1)
13832                 {
13833                   insn3 = bfd_get_32 (input_bfd,
13834                                       contents + offset + 4);
13835                   if (insn3 == NOP
13836                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13837                     {
13838                       rel[1].r_offset += 4;
13839                       bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13840                       insn2 = NOP;
13841                     }
13842                   bfd_put_32 (input_bfd, insn2, contents + offset);
13843                 }
13844               if ((tls_mask & tls_gd) == 0
13845                   && (tls_gd == 0 || toc_symndx != 0))
13846                 {
13847                   /* We changed the symbol.  Start over in order
13848                      to get h, sym, sec etc. right.  */
13849                   goto again;
13850                 }
13851             }
13852           break;
13853
13854         case R_PPC64_TLSGD:
13855           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13856             {
13857               unsigned int insn2, insn3;
13858               bfd_vma offset = rel->r_offset;
13859
13860               if ((tls_mask & TLS_TPRELGD) != 0)
13861                 {
13862                   /* IE */
13863                   r_type = R_PPC64_NONE;
13864                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13865                 }
13866               else
13867                 {
13868                   /* LE */
13869                   if (toc_symndx != 0)
13870                     {
13871                       r_symndx = toc_symndx;
13872                       rel->r_addend = toc_addend;
13873                     }
13874                   r_type = R_PPC64_TPREL16_LO;
13875                   rel->r_offset = offset + d_offset;
13876                   insn2 = 0x38630000;   /* addi 3,3,0 */
13877                 }
13878               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13879               /* Zap the reloc on the _tls_get_addr call too.  */
13880               BFD_ASSERT (offset == rel[1].r_offset);
13881               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13882               insn3 = bfd_get_32 (input_bfd,
13883                                   contents + offset + 4);
13884               if (insn3 == NOP
13885                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13886                 {
13887                   rel->r_offset += 4;
13888                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13889                   insn2 = NOP;
13890                 }
13891               bfd_put_32 (input_bfd, insn2, contents + offset);
13892               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13893                 goto again;
13894             }
13895           break;
13896
13897         case R_PPC64_TLSLD:
13898           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13899             {
13900               unsigned int insn2, insn3;
13901               bfd_vma offset = rel->r_offset;
13902
13903               if (toc_symndx)
13904                 sec = local_sections[toc_symndx];
13905               for (r_symndx = 0;
13906                    r_symndx < symtab_hdr->sh_info;
13907                    r_symndx++)
13908                 if (local_sections[r_symndx] == sec)
13909                   break;
13910               if (r_symndx >= symtab_hdr->sh_info)
13911                 r_symndx = STN_UNDEF;
13912               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13913               if (r_symndx != STN_UNDEF)
13914                 rel->r_addend -= (local_syms[r_symndx].st_value
13915                                   + sec->output_offset
13916                                   + sec->output_section->vma);
13917
13918               r_type = R_PPC64_TPREL16_LO;
13919               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13920               rel->r_offset = offset + d_offset;
13921               /* Zap the reloc on the _tls_get_addr call too.  */
13922               BFD_ASSERT (offset == rel[1].r_offset);
13923               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13924               insn2 = 0x38630000;       /* addi 3,3,0 */
13925               insn3 = bfd_get_32 (input_bfd,
13926                                   contents + offset + 4);
13927               if (insn3 == NOP
13928                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13929                 {
13930                   rel->r_offset += 4;
13931                   bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13932                   insn2 = NOP;
13933                 }
13934               bfd_put_32 (input_bfd, insn2, contents + offset);
13935               goto again;
13936             }
13937           break;
13938
13939         case R_PPC64_DTPMOD64:
13940           if (rel + 1 < relend
13941               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13942               && rel[1].r_offset == rel->r_offset + 8)
13943             {
13944               if ((tls_mask & TLS_GD) == 0)
13945                 {
13946                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13947                   if ((tls_mask & TLS_TPRELGD) != 0)
13948                     r_type = R_PPC64_TPREL64;
13949                   else
13950                     {
13951                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13952                       r_type = R_PPC64_NONE;
13953                     }
13954                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13955                 }
13956             }
13957           else
13958             {
13959               if ((tls_mask & TLS_LD) == 0)
13960                 {
13961                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13962                   r_type = R_PPC64_NONE;
13963                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13964                 }
13965             }
13966           break;
13967
13968         case R_PPC64_TPREL64:
13969           if ((tls_mask & TLS_TPREL) == 0)
13970             {
13971               r_type = R_PPC64_NONE;
13972               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13973             }
13974           break;
13975
13976         case R_PPC64_ENTRY:
13977           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13978           if (!bfd_link_pic (info)
13979               && !info->traditional_format
13980               && relocation + 0x80008000 <= 0xffffffff)
13981             {
13982               unsigned int insn1, insn2;
13983
13984               insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13985               insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13986               if ((insn1 & ~0xfffc) == LD_R2_0R12
13987                   && insn2 == ADD_R2_R2_R12)
13988                 {
13989                   bfd_put_32 (input_bfd,
13990                               LIS_R2 + PPC_HA (relocation),
13991                               contents + rel->r_offset);
13992                   bfd_put_32 (input_bfd,
13993                               ADDI_R2_R2 + PPC_LO (relocation),
13994                               contents + rel->r_offset + 4);
13995                 }
13996             }
13997           else
13998             {
13999               relocation -= (rel->r_offset
14000                              + input_section->output_offset
14001                              + input_section->output_section->vma);
14002               if (relocation + 0x80008000 <= 0xffffffff)
14003                 {
14004                   unsigned int insn1, insn2;
14005
14006                   insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14007                   insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14008                   if ((insn1 & ~0xfffc) == LD_R2_0R12
14009                       && insn2 == ADD_R2_R2_R12)
14010                     {
14011                       bfd_put_32 (input_bfd,
14012                                   ADDIS_R2_R12 + PPC_HA (relocation),
14013                                   contents + rel->r_offset);
14014                       bfd_put_32 (input_bfd,
14015                                   ADDI_R2_R2 + PPC_LO (relocation),
14016                                   contents + rel->r_offset + 4);
14017                     }
14018                 }
14019             }
14020           break;
14021
14022         case R_PPC64_REL16_HA:
14023           /* If we are generating a non-PIC executable, edit
14024              .  0:      addis 2,12,.TOC.-0b@ha
14025              .          addi 2,2,.TOC.-0b@l
14026              used by ELFv2 global entry points to set up r2, to
14027              .          lis 2,.TOC.@ha
14028              .          addi 2,2,.TOC.@l
14029              if .TOC. is in range.  */
14030           if (!bfd_link_pic (info)
14031               && !info->traditional_format
14032               && !htab->opd_abi
14033               && rel->r_addend == d_offset
14034               && h != NULL && &h->elf == htab->elf.hgot
14035               && rel + 1 < relend
14036               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14037               && rel[1].r_offset == rel->r_offset + 4
14038               && rel[1].r_addend == rel->r_addend + 4
14039               && relocation + 0x80008000 <= 0xffffffff)
14040             {
14041               unsigned int insn1, insn2;
14042               bfd_vma offset = rel->r_offset - d_offset;
14043               insn1 = bfd_get_32 (input_bfd, contents + offset);
14044               insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14045               if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14046                   && (insn2 & 0xffff0000) == ADDI_R2_R2)
14047                 {
14048                   r_type = R_PPC64_ADDR16_HA;
14049                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14050                   rel->r_addend -= d_offset;
14051                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14052                   rel[1].r_addend -= d_offset + 4;
14053                   bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14054                 }
14055             }
14056           break;
14057         }
14058
14059       /* Handle other relocations that tweak non-addend part of insn.  */
14060       insn = 0;
14061       max_br_offset = 1 << 25;
14062       addend = rel->r_addend;
14063       reloc_dest = DEST_NORMAL;
14064       switch (r_type)
14065         {
14066         default:
14067           break;
14068
14069         case R_PPC64_TOCSAVE:
14070           if (relocation + addend == (rel->r_offset
14071                                       + input_section->output_offset
14072                                       + input_section->output_section->vma)
14073               && tocsave_find (htab, NO_INSERT,
14074                                &local_syms, rel, input_bfd))
14075             {
14076               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14077               if (insn == NOP
14078                   || insn == CROR_151515 || insn == CROR_313131)
14079                 bfd_put_32 (input_bfd,
14080                             STD_R2_0R1 + STK_TOC (htab),
14081                             contents + rel->r_offset);
14082             }
14083           break;
14084
14085           /* Branch taken prediction relocations.  */
14086         case R_PPC64_ADDR14_BRTAKEN:
14087         case R_PPC64_REL14_BRTAKEN:
14088           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
14089           /* Fall through.  */
14090
14091           /* Branch not taken prediction relocations.  */
14092         case R_PPC64_ADDR14_BRNTAKEN:
14093         case R_PPC64_REL14_BRNTAKEN:
14094           insn |= bfd_get_32 (input_bfd,
14095                               contents + rel->r_offset) & ~(0x01 << 21);
14096           /* Fall through.  */
14097
14098         case R_PPC64_REL14:
14099           max_br_offset = 1 << 15;
14100           /* Fall through.  */
14101
14102         case R_PPC64_REL24:
14103           /* Calls to functions with a different TOC, such as calls to
14104              shared objects, need to alter the TOC pointer.  This is
14105              done using a linkage stub.  A REL24 branching to these
14106              linkage stubs needs to be followed by a nop, as the nop
14107              will be replaced with an instruction to restore the TOC
14108              base pointer.  */
14109           fdh = h;
14110           if (h != NULL
14111               && h->oh != NULL
14112               && h->oh->is_func_descriptor)
14113             fdh = ppc_follow_link (h->oh);
14114           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14115                                            htab);
14116           if (stub_entry != NULL
14117               && (stub_entry->stub_type == ppc_stub_plt_call
14118                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
14119                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14120                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14121             {
14122               bfd_boolean can_plt_call = FALSE;
14123
14124               /* All of these stubs will modify r2, so there must be a
14125                  branch and link followed by a nop.  The nop is
14126                  replaced by an insn to restore r2.  */
14127               if (rel->r_offset + 8 <= input_section->size)
14128                 {
14129                   unsigned long br;
14130
14131                   br = bfd_get_32 (input_bfd,
14132                                    contents + rel->r_offset);
14133                   if ((br & 1) != 0)
14134                     {
14135                       unsigned long nop;
14136
14137                       nop = bfd_get_32 (input_bfd,
14138                                         contents + rel->r_offset + 4);
14139                       if (nop == NOP
14140                           || nop == CROR_151515 || nop == CROR_313131)
14141                         {
14142                           if (h != NULL
14143                               && (h == htab->tls_get_addr_fd
14144                                   || h == htab->tls_get_addr)
14145                               && htab->params->tls_get_addr_opt)
14146                             {
14147                               /* Special stub used, leave nop alone.  */
14148                             }
14149                           else
14150                             bfd_put_32 (input_bfd,
14151                                         LD_R2_0R1 + STK_TOC (htab),
14152                                         contents + rel->r_offset + 4);
14153                           can_plt_call = TRUE;
14154                         }
14155                     }
14156                 }
14157
14158               if (!can_plt_call && h != NULL)
14159                 {
14160                   const char *name = h->elf.root.root.string;
14161
14162                   if (*name == '.')
14163                     ++name;
14164
14165                   if (strncmp (name, "__libc_start_main", 17) == 0
14166                       && (name[17] == 0 || name[17] == '@'))
14167                     {
14168                       /* Allow crt1 branch to go via a toc adjusting
14169                          stub.  Other calls that never return could do
14170                          the same, if we could detect such.  */
14171                       can_plt_call = TRUE;
14172                     }
14173                 }
14174
14175               if (!can_plt_call)
14176                 {
14177                   /* g++ as of 20130507 emits self-calls without a
14178                      following nop.  This is arguably wrong since we
14179                      have conflicting information.  On the one hand a
14180                      global symbol and on the other a local call
14181                      sequence, but don't error for this special case.
14182                      It isn't possible to cheaply verify we have
14183                      exactly such a call.  Allow all calls to the same
14184                      section.  */
14185                   asection *code_sec = sec;
14186
14187                   if (get_opd_info (sec) != NULL)
14188                     {
14189                       bfd_vma off = (relocation + addend
14190                                      - sec->output_section->vma
14191                                      - sec->output_offset);
14192
14193                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14194                     }
14195                   if (code_sec == input_section)
14196                     can_plt_call = TRUE;
14197                 }
14198
14199               if (!can_plt_call)
14200                 {
14201                   if (stub_entry->stub_type == ppc_stub_plt_call
14202                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14203                     info->callbacks->einfo
14204                       /* xgettext:c-format */
14205                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14206                          "recompile with -fPIC\n"),
14207                        input_bfd, input_section, rel->r_offset, sym_name);
14208                   else
14209                     info->callbacks->einfo
14210                       /* xgettext:c-format */
14211                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14212                          "(-mcmodel=small toc adjust stub)\n"),
14213                        input_bfd, input_section, rel->r_offset, sym_name);
14214
14215                   bfd_set_error (bfd_error_bad_value);
14216                   ret = FALSE;
14217                 }
14218
14219               if (can_plt_call
14220                   && (stub_entry->stub_type == ppc_stub_plt_call
14221                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14222                 unresolved_reloc = FALSE;
14223             }
14224
14225           if ((stub_entry == NULL
14226                || stub_entry->stub_type == ppc_stub_long_branch
14227                || stub_entry->stub_type == ppc_stub_plt_branch)
14228               && get_opd_info (sec) != NULL)
14229             {
14230               /* The branch destination is the value of the opd entry. */
14231               bfd_vma off = (relocation + addend
14232                              - sec->output_section->vma
14233                              - sec->output_offset);
14234               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14235               if (dest != (bfd_vma) -1)
14236                 {
14237                   relocation = dest;
14238                   addend = 0;
14239                   reloc_dest = DEST_OPD;
14240                 }
14241             }
14242
14243           /* If the branch is out of reach we ought to have a long
14244              branch stub.  */
14245           from = (rel->r_offset
14246                   + input_section->output_offset
14247                   + input_section->output_section->vma);
14248
14249           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14250                                                   ? fdh->elf.other
14251                                                   : sym->st_other);
14252
14253           if (stub_entry != NULL
14254               && (stub_entry->stub_type == ppc_stub_long_branch
14255                   || stub_entry->stub_type == ppc_stub_plt_branch)
14256               && (r_type == R_PPC64_ADDR14_BRTAKEN
14257                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14258                   || (relocation + addend - from + max_br_offset
14259                       < 2 * max_br_offset)))
14260             /* Don't use the stub if this branch is in range.  */
14261             stub_entry = NULL;
14262
14263           if (stub_entry != NULL)
14264             {
14265               /* Munge up the value and addend so that we call the stub
14266                  rather than the procedure directly.  */
14267               asection *stub_sec = stub_entry->group->stub_sec;
14268
14269               if (stub_entry->stub_type == ppc_stub_save_res)
14270                 relocation += (stub_sec->output_offset
14271                                + stub_sec->output_section->vma
14272                                + stub_sec->size - htab->sfpr->size
14273                                - htab->sfpr->output_offset
14274                                - htab->sfpr->output_section->vma);
14275               else
14276                 relocation = (stub_entry->stub_offset
14277                               + stub_sec->output_offset
14278                               + stub_sec->output_section->vma);
14279               addend = 0;
14280               reloc_dest = DEST_STUB;
14281
14282               if ((stub_entry->stub_type == ppc_stub_plt_call
14283                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14284                   && (ALWAYS_EMIT_R2SAVE
14285                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14286                   && rel + 1 < relend
14287                   && rel[1].r_offset == rel->r_offset + 4
14288                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14289                 relocation += 4;
14290             }
14291
14292           if (insn != 0)
14293             {
14294               if (is_isa_v2)
14295                 {
14296                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14297                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14298                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14299                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14300                     insn |= 0x02 << 21;
14301                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14302                     insn |= 0x08 << 21;
14303                   else
14304                     break;
14305                 }
14306               else
14307                 {
14308                   /* Invert 'y' bit if not the default.  */
14309                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14310                     insn ^= 0x01 << 21;
14311                 }
14312
14313               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14314             }
14315
14316           /* NOP out calls to undefined weak functions.
14317              We can thus call a weak function without first
14318              checking whether the function is defined.  */
14319           else if (h != NULL
14320                    && h->elf.root.type == bfd_link_hash_undefweak
14321                    && h->elf.dynindx == -1
14322                    && r_type == R_PPC64_REL24
14323                    && relocation == 0
14324                    && addend == 0)
14325             {
14326               bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14327               goto copy_reloc;
14328             }
14329           break;
14330         }
14331
14332       /* Set `addend'.  */
14333       tls_type = 0;
14334       switch (r_type)
14335         {
14336         default:
14337           info->callbacks->einfo
14338             /* xgettext:c-format */
14339             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14340              input_bfd, (int) r_type, sym_name);
14341
14342           bfd_set_error (bfd_error_bad_value);
14343           ret = FALSE;
14344           goto copy_reloc;
14345
14346         case R_PPC64_NONE:
14347         case R_PPC64_TLS:
14348         case R_PPC64_TLSGD:
14349         case R_PPC64_TLSLD:
14350         case R_PPC64_TOCSAVE:
14351         case R_PPC64_GNU_VTINHERIT:
14352         case R_PPC64_GNU_VTENTRY:
14353         case R_PPC64_ENTRY:
14354           goto copy_reloc;
14355
14356           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14357              address in the GOT as relocation value instead of the
14358              symbol's value itself.  Also, create a GOT entry for the
14359              symbol and put the symbol value there.  */
14360         case R_PPC64_GOT_TLSGD16:
14361         case R_PPC64_GOT_TLSGD16_LO:
14362         case R_PPC64_GOT_TLSGD16_HI:
14363         case R_PPC64_GOT_TLSGD16_HA:
14364           tls_type = TLS_TLS | TLS_GD;
14365           goto dogot;
14366
14367         case R_PPC64_GOT_TLSLD16:
14368         case R_PPC64_GOT_TLSLD16_LO:
14369         case R_PPC64_GOT_TLSLD16_HI:
14370         case R_PPC64_GOT_TLSLD16_HA:
14371           tls_type = TLS_TLS | TLS_LD;
14372           goto dogot;
14373
14374         case R_PPC64_GOT_TPREL16_DS:
14375         case R_PPC64_GOT_TPREL16_LO_DS:
14376         case R_PPC64_GOT_TPREL16_HI:
14377         case R_PPC64_GOT_TPREL16_HA:
14378           tls_type = TLS_TLS | TLS_TPREL;
14379           goto dogot;
14380
14381         case R_PPC64_GOT_DTPREL16_DS:
14382         case R_PPC64_GOT_DTPREL16_LO_DS:
14383         case R_PPC64_GOT_DTPREL16_HI:
14384         case R_PPC64_GOT_DTPREL16_HA:
14385           tls_type = TLS_TLS | TLS_DTPREL;
14386           goto dogot;
14387
14388         case R_PPC64_GOT16:
14389         case R_PPC64_GOT16_LO:
14390         case R_PPC64_GOT16_HI:
14391         case R_PPC64_GOT16_HA:
14392         case R_PPC64_GOT16_DS:
14393         case R_PPC64_GOT16_LO_DS:
14394         dogot:
14395           {
14396             /* Relocation is to the entry for this symbol in the global
14397                offset table.  */
14398             asection *got;
14399             bfd_vma *offp;
14400             bfd_vma off;
14401             unsigned long indx = 0;
14402             struct got_entry *ent;
14403
14404             if (tls_type == (TLS_TLS | TLS_LD)
14405                 && (h == NULL
14406                     || !h->elf.def_dynamic))
14407               ent = ppc64_tlsld_got (input_bfd);
14408             else
14409               {
14410
14411                 if (h != NULL)
14412                   {
14413                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14414                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14415                                                           &h->elf)
14416                         || (bfd_link_pic (info)
14417                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14418                       /* This is actually a static link, or it is a
14419                          -Bsymbolic link and the symbol is defined
14420                          locally, or the symbol was forced to be local
14421                          because of a version file.  */
14422                       ;
14423                     else
14424                       {
14425                         BFD_ASSERT (h->elf.dynindx != -1);
14426                         indx = h->elf.dynindx;
14427                         unresolved_reloc = FALSE;
14428                       }
14429                     ent = h->elf.got.glist;
14430                   }
14431                 else
14432                   {
14433                     if (local_got_ents == NULL)
14434                       abort ();
14435                     ent = local_got_ents[r_symndx];
14436                   }
14437
14438                 for (; ent != NULL; ent = ent->next)
14439                   if (ent->addend == orig_rel.r_addend
14440                       && ent->owner == input_bfd
14441                       && ent->tls_type == tls_type)
14442                     break;
14443               }
14444
14445             if (ent == NULL)
14446               abort ();
14447             if (ent->is_indirect)
14448               ent = ent->got.ent;
14449             offp = &ent->got.offset;
14450             got = ppc64_elf_tdata (ent->owner)->got;
14451             if (got == NULL)
14452               abort ();
14453
14454             /* The offset must always be a multiple of 8.  We use the
14455                least significant bit to record whether we have already
14456                processed this entry.  */
14457             off = *offp;
14458             if ((off & 1) != 0)
14459               off &= ~1;
14460             else
14461               {
14462                 /* Generate relocs for the dynamic linker, except in
14463                    the case of TLSLD where we'll use one entry per
14464                    module.  */
14465                 asection *relgot;
14466                 bfd_boolean ifunc;
14467
14468                 *offp = off | 1;
14469                 relgot = NULL;
14470                 ifunc = (h != NULL
14471                          ? h->elf.type == STT_GNU_IFUNC
14472                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14473                 if (ifunc)
14474                   relgot = htab->elf.irelplt;
14475                 else if ((bfd_link_pic (info) || indx != 0)
14476                          && (h == NULL
14477                              || (tls_type == (TLS_TLS | TLS_LD)
14478                                  && !h->elf.def_dynamic)
14479                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14480                              || h->elf.root.type != bfd_link_hash_undefweak))
14481                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14482                 if (relgot != NULL)
14483                   {
14484                     outrel.r_offset = (got->output_section->vma
14485                                        + got->output_offset
14486                                        + off);
14487                     outrel.r_addend = addend;
14488                     if (tls_type & (TLS_LD | TLS_GD))
14489                       {
14490                         outrel.r_addend = 0;
14491                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14492                         if (tls_type == (TLS_TLS | TLS_GD))
14493                           {
14494                             loc = relgot->contents;
14495                             loc += (relgot->reloc_count++
14496                                     * sizeof (Elf64_External_Rela));
14497                             bfd_elf64_swap_reloca_out (output_bfd,
14498                                                        &outrel, loc);
14499                             outrel.r_offset += 8;
14500                             outrel.r_addend = addend;
14501                             outrel.r_info
14502                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14503                           }
14504                       }
14505                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14506                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14507                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14508                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14509                     else if (indx != 0)
14510                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14511                     else
14512                       {
14513                         if (ifunc)
14514                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14515                         else
14516                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14517
14518                         /* Write the .got section contents for the sake
14519                            of prelink.  */
14520                         loc = got->contents + off;
14521                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14522                                     loc);
14523                       }
14524
14525                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14526                       {
14527                         outrel.r_addend += relocation;
14528                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14529                           {
14530                             if (htab->elf.tls_sec == NULL)
14531                               outrel.r_addend = 0;
14532                             else
14533                               outrel.r_addend -= htab->elf.tls_sec->vma;
14534                           }
14535                       }
14536                     loc = relgot->contents;
14537                     loc += (relgot->reloc_count++
14538                             * sizeof (Elf64_External_Rela));
14539                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14540                   }
14541
14542                 /* Init the .got section contents here if we're not
14543                    emitting a reloc.  */
14544                 else
14545                   {
14546                     relocation += addend;
14547                     if (tls_type == (TLS_TLS | TLS_LD))
14548                       relocation = 1;
14549                     else if (tls_type != 0)
14550                       {
14551                         if (htab->elf.tls_sec == NULL)
14552                           relocation = 0;
14553                         else
14554                           {
14555                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14556                             if (tls_type == (TLS_TLS | TLS_TPREL))
14557                               relocation += DTP_OFFSET - TP_OFFSET;
14558                           }
14559
14560                         if (tls_type == (TLS_TLS | TLS_GD))
14561                           {
14562                             bfd_put_64 (output_bfd, relocation,
14563                                         got->contents + off + 8);
14564                             relocation = 1;
14565                           }
14566                       }
14567
14568                     bfd_put_64 (output_bfd, relocation,
14569                                 got->contents + off);
14570                   }
14571               }
14572
14573             if (off >= (bfd_vma) -2)
14574               abort ();
14575
14576             relocation = got->output_section->vma + got->output_offset + off;
14577             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14578           }
14579           break;
14580
14581         case R_PPC64_PLT16_HA:
14582         case R_PPC64_PLT16_HI:
14583         case R_PPC64_PLT16_LO:
14584         case R_PPC64_PLT32:
14585         case R_PPC64_PLT64:
14586           /* Relocation is to the entry for this symbol in the
14587              procedure linkage table.  */
14588           {
14589             struct plt_entry **plt_list = NULL;
14590             if (h != NULL)
14591               plt_list = &h->elf.plt.plist;
14592             else if (local_got_ents != NULL)
14593               {
14594                 struct plt_entry **local_plt = (struct plt_entry **)
14595                   (local_got_ents + symtab_hdr->sh_info);
14596                 unsigned char *local_got_tls_masks = (unsigned char *)
14597                   (local_plt + symtab_hdr->sh_info);
14598                 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14599                   plt_list = local_plt + r_symndx;
14600               }
14601             if (plt_list)
14602               {
14603                 struct plt_entry *ent;
14604
14605                 for (ent = *plt_list; ent != NULL; ent = ent->next)
14606                   if (ent->plt.offset != (bfd_vma) -1
14607                       && ent->addend == orig_rel.r_addend)
14608                     {
14609                       asection *plt;
14610
14611                       plt = htab->elf.splt;
14612                       if (!htab->elf.dynamic_sections_created
14613                           || h == NULL
14614                           || h->elf.dynindx == -1)
14615                         plt = htab->elf.iplt;
14616                       relocation = (plt->output_section->vma
14617                                     + plt->output_offset
14618                                     + ent->plt.offset);
14619                       addend = 0;
14620                       unresolved_reloc = FALSE;
14621                       break;
14622                     }
14623               }
14624           }
14625           break;
14626
14627         case R_PPC64_TOC:
14628           /* Relocation value is TOC base.  */
14629           relocation = TOCstart;
14630           if (r_symndx == STN_UNDEF)
14631             relocation += htab->sec_info[input_section->id].toc_off;
14632           else if (unresolved_reloc)
14633             ;
14634           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14635             relocation += htab->sec_info[sec->id].toc_off;
14636           else
14637             unresolved_reloc = TRUE;
14638           goto dodyn;
14639
14640           /* TOC16 relocs.  We want the offset relative to the TOC base,
14641              which is the address of the start of the TOC plus 0x8000.
14642              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14643              in this order.  */
14644         case R_PPC64_TOC16:
14645         case R_PPC64_TOC16_LO:
14646         case R_PPC64_TOC16_HI:
14647         case R_PPC64_TOC16_DS:
14648         case R_PPC64_TOC16_LO_DS:
14649         case R_PPC64_TOC16_HA:
14650           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14651           break;
14652
14653           /* Relocate against the beginning of the section.  */
14654         case R_PPC64_SECTOFF:
14655         case R_PPC64_SECTOFF_LO:
14656         case R_PPC64_SECTOFF_HI:
14657         case R_PPC64_SECTOFF_DS:
14658         case R_PPC64_SECTOFF_LO_DS:
14659         case R_PPC64_SECTOFF_HA:
14660           if (sec != NULL)
14661             addend -= sec->output_section->vma;
14662           break;
14663
14664         case R_PPC64_REL16:
14665         case R_PPC64_REL16_LO:
14666         case R_PPC64_REL16_HI:
14667         case R_PPC64_REL16_HA:
14668         case R_PPC64_REL16DX_HA:
14669           break;
14670
14671         case R_PPC64_REL14:
14672         case R_PPC64_REL14_BRNTAKEN:
14673         case R_PPC64_REL14_BRTAKEN:
14674         case R_PPC64_REL24:
14675           break;
14676
14677         case R_PPC64_TPREL16:
14678         case R_PPC64_TPREL16_LO:
14679         case R_PPC64_TPREL16_HI:
14680         case R_PPC64_TPREL16_HA:
14681         case R_PPC64_TPREL16_DS:
14682         case R_PPC64_TPREL16_LO_DS:
14683         case R_PPC64_TPREL16_HIGH:
14684         case R_PPC64_TPREL16_HIGHA:
14685         case R_PPC64_TPREL16_HIGHER:
14686         case R_PPC64_TPREL16_HIGHERA:
14687         case R_PPC64_TPREL16_HIGHEST:
14688         case R_PPC64_TPREL16_HIGHESTA:
14689           if (h != NULL
14690               && h->elf.root.type == bfd_link_hash_undefweak
14691               && h->elf.dynindx == -1)
14692             {
14693               /* Make this relocation against an undefined weak symbol
14694                  resolve to zero.  This is really just a tweak, since
14695                  code using weak externs ought to check that they are
14696                  defined before using them.  */
14697               bfd_byte *p = contents + rel->r_offset - d_offset;
14698
14699               insn = bfd_get_32 (input_bfd, p);
14700               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14701               if (insn != 0)
14702                 bfd_put_32 (input_bfd, insn, p);
14703               break;
14704             }
14705           if (htab->elf.tls_sec != NULL)
14706             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14707           if (bfd_link_pic (info))
14708             /* The TPREL16 relocs shouldn't really be used in shared
14709                libs as they will result in DT_TEXTREL being set, but
14710                support them anyway.  */
14711             goto dodyn;
14712           break;
14713
14714         case R_PPC64_DTPREL16:
14715         case R_PPC64_DTPREL16_LO:
14716         case R_PPC64_DTPREL16_HI:
14717         case R_PPC64_DTPREL16_HA:
14718         case R_PPC64_DTPREL16_DS:
14719         case R_PPC64_DTPREL16_LO_DS:
14720         case R_PPC64_DTPREL16_HIGH:
14721         case R_PPC64_DTPREL16_HIGHA:
14722         case R_PPC64_DTPREL16_HIGHER:
14723         case R_PPC64_DTPREL16_HIGHERA:
14724         case R_PPC64_DTPREL16_HIGHEST:
14725         case R_PPC64_DTPREL16_HIGHESTA:
14726           if (htab->elf.tls_sec != NULL)
14727             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14728           break;
14729
14730         case R_PPC64_ADDR64_LOCAL:
14731           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14732                                               ? h->elf.other
14733                                               : sym->st_other);
14734           break;
14735
14736         case R_PPC64_DTPMOD64:
14737           relocation = 1;
14738           addend = 0;
14739           goto dodyn;
14740
14741         case R_PPC64_TPREL64:
14742           if (htab->elf.tls_sec != NULL)
14743             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14744           goto dodyn;
14745
14746         case R_PPC64_DTPREL64:
14747           if (htab->elf.tls_sec != NULL)
14748             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14749           /* Fall through.  */
14750
14751           /* Relocations that may need to be propagated if this is a
14752              dynamic object.  */
14753         case R_PPC64_REL30:
14754         case R_PPC64_REL32:
14755         case R_PPC64_REL64:
14756         case R_PPC64_ADDR14:
14757         case R_PPC64_ADDR14_BRNTAKEN:
14758         case R_PPC64_ADDR14_BRTAKEN:
14759         case R_PPC64_ADDR16:
14760         case R_PPC64_ADDR16_DS:
14761         case R_PPC64_ADDR16_HA:
14762         case R_PPC64_ADDR16_HI:
14763         case R_PPC64_ADDR16_HIGH:
14764         case R_PPC64_ADDR16_HIGHA:
14765         case R_PPC64_ADDR16_HIGHER:
14766         case R_PPC64_ADDR16_HIGHERA:
14767         case R_PPC64_ADDR16_HIGHEST:
14768         case R_PPC64_ADDR16_HIGHESTA:
14769         case R_PPC64_ADDR16_LO:
14770         case R_PPC64_ADDR16_LO_DS:
14771         case R_PPC64_ADDR24:
14772         case R_PPC64_ADDR32:
14773         case R_PPC64_ADDR64:
14774         case R_PPC64_UADDR16:
14775         case R_PPC64_UADDR32:
14776         case R_PPC64_UADDR64:
14777         dodyn:
14778           if ((input_section->flags & SEC_ALLOC) == 0)
14779             break;
14780
14781           if (NO_OPD_RELOCS && is_opd)
14782             break;
14783
14784           if (bfd_link_pic (info)
14785               ? ((h != NULL && pc_dynrelocs (h))
14786                  || must_be_dyn_reloc (info, r_type))
14787               : (h != NULL
14788                  ? h->dyn_relocs != NULL
14789                  : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14790             {
14791               bfd_boolean skip, relocate;
14792               asection *sreloc;
14793               bfd_vma out_off;
14794
14795               /* When generating a dynamic object, these relocations
14796                  are copied into the output file to be resolved at run
14797                  time.  */
14798
14799               skip = FALSE;
14800               relocate = FALSE;
14801
14802               out_off = _bfd_elf_section_offset (output_bfd, info,
14803                                                  input_section, rel->r_offset);
14804               if (out_off == (bfd_vma) -1)
14805                 skip = TRUE;
14806               else if (out_off == (bfd_vma) -2)
14807                 skip = TRUE, relocate = TRUE;
14808               out_off += (input_section->output_section->vma
14809                           + input_section->output_offset);
14810               outrel.r_offset = out_off;
14811               outrel.r_addend = rel->r_addend;
14812
14813               /* Optimize unaligned reloc use.  */
14814               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14815                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14816                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14817               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14818                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14819                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14820               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14821                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14822                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14823
14824               if (skip)
14825                 memset (&outrel, 0, sizeof outrel);
14826               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14827                        && !is_opd
14828                        && r_type != R_PPC64_TOC)
14829                 {
14830                   BFD_ASSERT (h->elf.dynindx != -1);
14831                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14832                 }
14833               else
14834                 {
14835                   /* This symbol is local, or marked to become local,
14836                      or this is an opd section reloc which must point
14837                      at a local function.  */
14838                   outrel.r_addend += relocation;
14839                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14840                     {
14841                       if (is_opd && h != NULL)
14842                         {
14843                           /* Lie about opd entries.  This case occurs
14844                              when building shared libraries and we
14845                              reference a function in another shared
14846                              lib.  The same thing happens for a weak
14847                              definition in an application that's
14848                              overridden by a strong definition in a
14849                              shared lib.  (I believe this is a generic
14850                              bug in binutils handling of weak syms.)
14851                              In these cases we won't use the opd
14852                              entry in this lib.  */
14853                           unresolved_reloc = FALSE;
14854                         }
14855                       if (!is_opd
14856                           && r_type == R_PPC64_ADDR64
14857                           && (h != NULL
14858                               ? h->elf.type == STT_GNU_IFUNC
14859                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14860                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14861                       else
14862                         {
14863                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14864
14865                           /* We need to relocate .opd contents for ld.so.
14866                              Prelink also wants simple and consistent rules
14867                              for relocs.  This make all RELATIVE relocs have
14868                              *r_offset equal to r_addend.  */
14869                           relocate = TRUE;
14870                         }
14871                     }
14872                   else
14873                     {
14874                       long indx = 0;
14875
14876                       if (h != NULL
14877                           ? h->elf.type == STT_GNU_IFUNC
14878                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14879                         {
14880                           info->callbacks->einfo
14881                             /* xgettext:c-format */
14882                             (_("%P: %H: %s for indirect "
14883                                "function `%T' unsupported\n"),
14884                              input_bfd, input_section, rel->r_offset,
14885                              ppc64_elf_howto_table[r_type]->name,
14886                              sym_name);
14887                           ret = FALSE;
14888                         }
14889                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14890                         ;
14891                       else if (sec == NULL || sec->owner == NULL)
14892                         {
14893                           bfd_set_error (bfd_error_bad_value);
14894                           return FALSE;
14895                         }
14896                       else
14897                         {
14898                           asection *osec;
14899
14900                           osec = sec->output_section;
14901                           indx = elf_section_data (osec)->dynindx;
14902
14903                           if (indx == 0)
14904                             {
14905                               if ((osec->flags & SEC_READONLY) == 0
14906                                   && htab->elf.data_index_section != NULL)
14907                                 osec = htab->elf.data_index_section;
14908                               else
14909                                 osec = htab->elf.text_index_section;
14910                               indx = elf_section_data (osec)->dynindx;
14911                             }
14912                           BFD_ASSERT (indx != 0);
14913
14914                           /* We are turning this relocation into one
14915                              against a section symbol, so subtract out
14916                              the output section's address but not the
14917                              offset of the input section in the output
14918                              section.  */
14919                           outrel.r_addend -= osec->vma;
14920                         }
14921
14922                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14923                     }
14924                 }
14925
14926               sreloc = elf_section_data (input_section)->sreloc;
14927               if (h != NULL
14928                   ? h->elf.type == STT_GNU_IFUNC
14929                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14930                 sreloc = htab->elf.irelplt;
14931               if (sreloc == NULL)
14932                 abort ();
14933
14934               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14935                   >= sreloc->size)
14936                 abort ();
14937               loc = sreloc->contents;
14938               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14939               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14940
14941               /* If this reloc is against an external symbol, it will
14942                  be computed at runtime, so there's no need to do
14943                  anything now.  However, for the sake of prelink ensure
14944                  that the section contents are a known value.  */
14945               if (! relocate)
14946                 {
14947                   unresolved_reloc = FALSE;
14948                   /* The value chosen here is quite arbitrary as ld.so
14949                      ignores section contents except for the special
14950                      case of .opd where the contents might be accessed
14951                      before relocation.  Choose zero, as that won't
14952                      cause reloc overflow.  */
14953                   relocation = 0;
14954                   addend = 0;
14955                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14956                      to improve backward compatibility with older
14957                      versions of ld.  */
14958                   if (r_type == R_PPC64_ADDR64)
14959                     addend = outrel.r_addend;
14960                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14961                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14962                     addend = (input_section->output_section->vma
14963                               + input_section->output_offset
14964                               + rel->r_offset);
14965                 }
14966             }
14967           break;
14968
14969         case R_PPC64_COPY:
14970         case R_PPC64_GLOB_DAT:
14971         case R_PPC64_JMP_SLOT:
14972         case R_PPC64_JMP_IREL:
14973         case R_PPC64_RELATIVE:
14974           /* We shouldn't ever see these dynamic relocs in relocatable
14975              files.  */
14976           /* Fall through.  */
14977
14978         case R_PPC64_PLTGOT16:
14979         case R_PPC64_PLTGOT16_DS:
14980         case R_PPC64_PLTGOT16_HA:
14981         case R_PPC64_PLTGOT16_HI:
14982         case R_PPC64_PLTGOT16_LO:
14983         case R_PPC64_PLTGOT16_LO_DS:
14984         case R_PPC64_PLTREL32:
14985         case R_PPC64_PLTREL64:
14986           /* These ones haven't been implemented yet.  */
14987
14988           info->callbacks->einfo
14989             /* xgettext:c-format */
14990             (_("%P: %B: %s is not supported for `%T'\n"),
14991              input_bfd,
14992              ppc64_elf_howto_table[r_type]->name, sym_name);
14993
14994           bfd_set_error (bfd_error_invalid_operation);
14995           ret = FALSE;
14996           goto copy_reloc;
14997         }
14998
14999       /* Multi-instruction sequences that access the TOC can be
15000          optimized, eg. addis ra,r2,0; addi rb,ra,x;
15001          to             nop;           addi rb,r2,x;  */
15002       switch (r_type)
15003         {
15004         default:
15005           break;
15006
15007         case R_PPC64_GOT_TLSLD16_HI:
15008         case R_PPC64_GOT_TLSGD16_HI:
15009         case R_PPC64_GOT_TPREL16_HI:
15010         case R_PPC64_GOT_DTPREL16_HI:
15011         case R_PPC64_GOT16_HI:
15012         case R_PPC64_TOC16_HI:
15013           /* These relocs would only be useful if building up an
15014              offset to later add to r2, perhaps in an indexed
15015              addressing mode instruction.  Don't try to optimize.
15016              Unfortunately, the possibility of someone building up an
15017              offset like this or even with the HA relocs, means that
15018              we need to check the high insn when optimizing the low
15019              insn.  */
15020           break;
15021
15022         case R_PPC64_GOT_TLSLD16_HA:
15023         case R_PPC64_GOT_TLSGD16_HA:
15024         case R_PPC64_GOT_TPREL16_HA:
15025         case R_PPC64_GOT_DTPREL16_HA:
15026         case R_PPC64_GOT16_HA:
15027         case R_PPC64_TOC16_HA:
15028           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15029               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15030             {
15031               bfd_byte *p = contents + (rel->r_offset & ~3);
15032               bfd_put_32 (input_bfd, NOP, p);
15033             }
15034           break;
15035
15036         case R_PPC64_GOT_TLSLD16_LO:
15037         case R_PPC64_GOT_TLSGD16_LO:
15038         case R_PPC64_GOT_TPREL16_LO_DS:
15039         case R_PPC64_GOT_DTPREL16_LO_DS:
15040         case R_PPC64_GOT16_LO:
15041         case R_PPC64_GOT16_LO_DS:
15042         case R_PPC64_TOC16_LO:
15043         case R_PPC64_TOC16_LO_DS:
15044           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15045               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15046             {
15047               bfd_byte *p = contents + (rel->r_offset & ~3);
15048               insn = bfd_get_32 (input_bfd, p);
15049               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15050                 {
15051                   /* Transform addic to addi when we change reg.  */
15052                   insn &= ~((0x3f << 26) | (0x1f << 16));
15053                   insn |= (14u << 26) | (2 << 16);
15054                 }
15055               else
15056                 {
15057                   insn &= ~(0x1f << 16);
15058                   insn |= 2 << 16;
15059                 }
15060               bfd_put_32 (input_bfd, insn, p);
15061             }
15062           break;
15063         }
15064
15065       /* Do any further special processing.  */
15066       howto = ppc64_elf_howto_table[(int) r_type];
15067       switch (r_type)
15068         {
15069         default:
15070           break;
15071
15072         case R_PPC64_REL16_HA:
15073         case R_PPC64_REL16DX_HA:
15074         case R_PPC64_ADDR16_HA:
15075         case R_PPC64_ADDR16_HIGHA:
15076         case R_PPC64_ADDR16_HIGHERA:
15077         case R_PPC64_ADDR16_HIGHESTA:
15078         case R_PPC64_TOC16_HA:
15079         case R_PPC64_SECTOFF_HA:
15080         case R_PPC64_TPREL16_HA:
15081         case R_PPC64_TPREL16_HIGHA:
15082         case R_PPC64_TPREL16_HIGHERA:
15083         case R_PPC64_TPREL16_HIGHESTA:
15084         case R_PPC64_DTPREL16_HA:
15085         case R_PPC64_DTPREL16_HIGHA:
15086         case R_PPC64_DTPREL16_HIGHERA:
15087         case R_PPC64_DTPREL16_HIGHESTA:
15088           /* It's just possible that this symbol is a weak symbol
15089              that's not actually defined anywhere. In that case,
15090              'sec' would be NULL, and we should leave the symbol
15091              alone (it will be set to zero elsewhere in the link).  */
15092           if (sec == NULL)
15093             break;
15094           /* Fall through.  */
15095
15096         case R_PPC64_GOT16_HA:
15097         case R_PPC64_PLTGOT16_HA:
15098         case R_PPC64_PLT16_HA:
15099         case R_PPC64_GOT_TLSGD16_HA:
15100         case R_PPC64_GOT_TLSLD16_HA:
15101         case R_PPC64_GOT_TPREL16_HA:
15102         case R_PPC64_GOT_DTPREL16_HA:
15103           /* Add 0x10000 if sign bit in 0:15 is set.
15104              Bits 0:15 are not used.  */
15105           addend += 0x8000;
15106           break;
15107
15108         case R_PPC64_ADDR16_DS:
15109         case R_PPC64_ADDR16_LO_DS:
15110         case R_PPC64_GOT16_DS:
15111         case R_PPC64_GOT16_LO_DS:
15112         case R_PPC64_PLT16_LO_DS:
15113         case R_PPC64_SECTOFF_DS:
15114         case R_PPC64_SECTOFF_LO_DS:
15115         case R_PPC64_TOC16_DS:
15116         case R_PPC64_TOC16_LO_DS:
15117         case R_PPC64_PLTGOT16_DS:
15118         case R_PPC64_PLTGOT16_LO_DS:
15119         case R_PPC64_GOT_TPREL16_DS:
15120         case R_PPC64_GOT_TPREL16_LO_DS:
15121         case R_PPC64_GOT_DTPREL16_DS:
15122         case R_PPC64_GOT_DTPREL16_LO_DS:
15123         case R_PPC64_TPREL16_DS:
15124         case R_PPC64_TPREL16_LO_DS:
15125         case R_PPC64_DTPREL16_DS:
15126         case R_PPC64_DTPREL16_LO_DS:
15127           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15128           mask = 3;
15129           /* If this reloc is against an lq, lxv, or stxv insn, then
15130              the value must be a multiple of 16.  This is somewhat of
15131              a hack, but the "correct" way to do this by defining _DQ
15132              forms of all the _DS relocs bloats all reloc switches in
15133              this file.  It doesn't make much sense to use these
15134              relocs in data, so testing the insn should be safe.  */
15135           if ((insn & (0x3f << 26)) == (56u << 26)
15136               || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15137             mask = 15;
15138           relocation += addend;
15139           addend = insn & (mask ^ 3);
15140           if ((relocation & mask) != 0)
15141             {
15142               relocation ^= relocation & mask;
15143               info->callbacks->einfo
15144                 /* xgettext:c-format */
15145                 (_("%P: %H: error: %s not a multiple of %u\n"),
15146                  input_bfd, input_section, rel->r_offset,
15147                  howto->name,
15148                  mask + 1);
15149               bfd_set_error (bfd_error_bad_value);
15150               ret = FALSE;
15151               goto copy_reloc;
15152             }
15153           break;
15154         }
15155
15156       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15157          because such sections are not SEC_ALLOC and thus ld.so will
15158          not process them.  */
15159       if (unresolved_reloc
15160           && !((input_section->flags & SEC_DEBUGGING) != 0
15161                && h->elf.def_dynamic)
15162           && _bfd_elf_section_offset (output_bfd, info, input_section,
15163                                       rel->r_offset) != (bfd_vma) -1)
15164         {
15165           info->callbacks->einfo
15166             /* xgettext:c-format */
15167             (_("%P: %H: unresolvable %s against `%T'\n"),
15168              input_bfd, input_section, rel->r_offset,
15169              howto->name,
15170              h->elf.root.root.string);
15171           ret = FALSE;
15172         }
15173
15174       /* 16-bit fields in insns mostly have signed values, but a
15175          few insns have 16-bit unsigned values.  Really, we should
15176          have different reloc types.  */
15177       if (howto->complain_on_overflow != complain_overflow_dont
15178           && howto->dst_mask == 0xffff
15179           && (input_section->flags & SEC_CODE) != 0)
15180         {
15181           enum complain_overflow complain = complain_overflow_signed;
15182
15183           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15184           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15185             complain = complain_overflow_bitfield;
15186           else if (howto->rightshift == 0
15187                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15188                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15189                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15190                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15191                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15192                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15193             complain = complain_overflow_unsigned;
15194           if (howto->complain_on_overflow != complain)
15195             {
15196               alt_howto = *howto;
15197               alt_howto.complain_on_overflow = complain;
15198               howto = &alt_howto;
15199             }
15200         }
15201
15202       if (r_type == R_PPC64_REL16DX_HA)
15203         {
15204           /* Split field reloc isn't handled by _bfd_final_link_relocate.  */
15205           if (rel->r_offset + 4 > input_section->size)
15206             r = bfd_reloc_outofrange;
15207           else
15208             {
15209               relocation += addend;
15210               relocation -= (rel->r_offset
15211                              + input_section->output_offset
15212                              + input_section->output_section->vma);
15213               relocation = (bfd_signed_vma) relocation >> 16;
15214               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15215               insn &= ~0x1fffc1;
15216               insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15217               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15218               r = bfd_reloc_ok;
15219               if (relocation + 0x8000 > 0xffff)
15220                 r = bfd_reloc_overflow;
15221             }
15222         }
15223       else
15224         r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15225                                       rel->r_offset, relocation, addend);
15226
15227       if (r != bfd_reloc_ok)
15228         {
15229           char *more_info = NULL;
15230           const char *reloc_name = howto->name;
15231
15232           if (reloc_dest != DEST_NORMAL)
15233             {
15234               more_info = bfd_malloc (strlen (reloc_name) + 8);
15235               if (more_info != NULL)
15236                 {
15237                   strcpy (more_info, reloc_name);
15238                   strcat (more_info, (reloc_dest == DEST_OPD
15239                                       ? " (OPD)" : " (stub)"));
15240                   reloc_name = more_info;
15241                 }
15242             }
15243
15244           if (r == bfd_reloc_overflow)
15245             {
15246               /* On code like "if (foo) foo();" don't report overflow
15247                  on a branch to zero when foo is undefined.  */
15248               if (!warned
15249                   && (reloc_dest == DEST_STUB
15250                       || !(h != NULL
15251                            && (h->elf.root.type == bfd_link_hash_undefweak
15252                                || h->elf.root.type == bfd_link_hash_undefined)
15253                            && is_branch_reloc (r_type))))
15254                 info->callbacks->reloc_overflow (info, &h->elf.root,
15255                                                  sym_name, reloc_name,
15256                                                  orig_rel.r_addend,
15257                                                  input_bfd, input_section,
15258                                                  rel->r_offset);
15259             }
15260           else
15261             {
15262               info->callbacks->einfo
15263                 /* xgettext:c-format */
15264                 (_("%P: %H: %s against `%T': error %d\n"),
15265                  input_bfd, input_section, rel->r_offset,
15266                  reloc_name, sym_name, (int) r);
15267               ret = FALSE;
15268             }
15269           if (more_info != NULL)
15270             free (more_info);
15271         }
15272     copy_reloc:
15273       if (wrel != rel)
15274         *wrel = *rel;
15275     }
15276
15277   if (wrel != rel)
15278     {
15279       Elf_Internal_Shdr *rel_hdr;
15280       size_t deleted = rel - wrel;
15281
15282       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15283       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15284       if (rel_hdr->sh_size == 0)
15285         {
15286           /* It is too late to remove an empty reloc section.  Leave
15287              one NONE reloc.
15288              ??? What is wrong with an empty section???  */
15289           rel_hdr->sh_size = rel_hdr->sh_entsize;
15290           deleted -= 1;
15291         }
15292       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15293       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15294       input_section->reloc_count -= deleted;
15295     }
15296
15297   /* If we're emitting relocations, then shortly after this function
15298      returns, reloc offsets and addends for this section will be
15299      adjusted.  Worse, reloc symbol indices will be for the output
15300      file rather than the input.  Save a copy of the relocs for
15301      opd_entry_value.  */
15302   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15303     {
15304       bfd_size_type amt;
15305       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15306       rel = bfd_alloc (input_bfd, amt);
15307       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15308       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15309       if (rel == NULL)
15310         return FALSE;
15311       memcpy (rel, relocs, amt);
15312     }
15313   return ret;
15314 }
15315
15316 /* Adjust the value of any local symbols in opd sections.  */
15317
15318 static int
15319 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15320                               const char *name ATTRIBUTE_UNUSED,
15321                               Elf_Internal_Sym *elfsym,
15322                               asection *input_sec,
15323                               struct elf_link_hash_entry *h)
15324 {
15325   struct _opd_sec_data *opd;
15326   long adjust;
15327   bfd_vma value;
15328
15329   if (h != NULL)
15330     return 1;
15331
15332   opd = get_opd_info (input_sec);
15333   if (opd == NULL || opd->adjust == NULL)
15334     return 1;
15335
15336   value = elfsym->st_value - input_sec->output_offset;
15337   if (!bfd_link_relocatable (info))
15338     value -= input_sec->output_section->vma;
15339
15340   adjust = opd->adjust[OPD_NDX (value)];
15341   if (adjust == -1)
15342     return 2;
15343
15344   elfsym->st_value += adjust;
15345   return 1;
15346 }
15347
15348 /* Finish up dynamic symbol handling.  We set the contents of various
15349    dynamic sections here.  */
15350
15351 static bfd_boolean
15352 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15353                                  struct bfd_link_info *info,
15354                                  struct elf_link_hash_entry *h,
15355                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15356 {
15357   struct ppc_link_hash_table *htab;
15358   struct plt_entry *ent;
15359   Elf_Internal_Rela rela;
15360   bfd_byte *loc;
15361
15362   htab = ppc_hash_table (info);
15363   if (htab == NULL)
15364     return FALSE;
15365
15366   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15367     if (ent->plt.offset != (bfd_vma) -1)
15368       {
15369         /* This symbol has an entry in the procedure linkage
15370            table.  Set it up.  */
15371         if (!htab->elf.dynamic_sections_created
15372             || h->dynindx == -1)
15373           {
15374             BFD_ASSERT (h->type == STT_GNU_IFUNC
15375                         && h->def_regular
15376                         && (h->root.type == bfd_link_hash_defined
15377                             || h->root.type == bfd_link_hash_defweak));
15378             rela.r_offset = (htab->elf.iplt->output_section->vma
15379                              + htab->elf.iplt->output_offset
15380                              + ent->plt.offset);
15381             if (htab->opd_abi)
15382               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15383             else
15384               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15385             rela.r_addend = (h->root.u.def.value
15386                              + h->root.u.def.section->output_offset
15387                              + h->root.u.def.section->output_section->vma
15388                              + ent->addend);
15389             loc = (htab->elf.irelplt->contents
15390                    + (htab->elf.irelplt->reloc_count++
15391                       * sizeof (Elf64_External_Rela)));
15392           }
15393         else
15394           {
15395             rela.r_offset = (htab->elf.splt->output_section->vma
15396                              + htab->elf.splt->output_offset
15397                              + ent->plt.offset);
15398             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15399             rela.r_addend = ent->addend;
15400             loc = (htab->elf.srelplt->contents
15401                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15402                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15403           }
15404         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15405
15406         if (!htab->opd_abi)
15407           {
15408             if (!h->def_regular)
15409               {
15410                 /* Mark the symbol as undefined, rather than as
15411                    defined in glink.  Leave the value if there were
15412                    any relocations where pointer equality matters
15413                    (this is a clue for the dynamic linker, to make
15414                    function pointer comparisons work between an
15415                    application and shared library), otherwise set it
15416                    to zero.  */
15417                 sym->st_shndx = SHN_UNDEF;
15418                 if (!h->pointer_equality_needed)
15419                   sym->st_value = 0;
15420                 else if (!h->ref_regular_nonweak)
15421                   {
15422                     /* This breaks function pointer comparisons, but
15423                        that is better than breaking tests for a NULL
15424                        function pointer.  */
15425                     sym->st_value = 0;
15426                   }
15427               }
15428           }
15429       }
15430
15431   if (h->needs_copy)
15432     {
15433       /* This symbol needs a copy reloc.  Set it up.  */
15434
15435       if (h->dynindx == -1
15436           || (h->root.type != bfd_link_hash_defined
15437               && h->root.type != bfd_link_hash_defweak)
15438           || htab->relbss == NULL)
15439         abort ();
15440
15441       rela.r_offset = (h->root.u.def.value
15442                        + h->root.u.def.section->output_section->vma
15443                        + h->root.u.def.section->output_offset);
15444       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15445       rela.r_addend = 0;
15446       loc = htab->relbss->contents;
15447       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15448       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15449     }
15450
15451   return TRUE;
15452 }
15453
15454 /* Used to decide how to sort relocs in an optimal manner for the
15455    dynamic linker, before writing them out.  */
15456
15457 static enum elf_reloc_type_class
15458 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15459                             const asection *rel_sec,
15460                             const Elf_Internal_Rela *rela)
15461 {
15462   enum elf_ppc64_reloc_type r_type;
15463   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15464
15465   if (rel_sec == htab->elf.irelplt)
15466     return reloc_class_ifunc;
15467
15468   r_type = ELF64_R_TYPE (rela->r_info);
15469   switch (r_type)
15470     {
15471     case R_PPC64_RELATIVE:
15472       return reloc_class_relative;
15473     case R_PPC64_JMP_SLOT:
15474       return reloc_class_plt;
15475     case R_PPC64_COPY:
15476       return reloc_class_copy;
15477     default:
15478       return reloc_class_normal;
15479     }
15480 }
15481
15482 /* Finish up the dynamic sections.  */
15483
15484 static bfd_boolean
15485 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15486                                    struct bfd_link_info *info)
15487 {
15488   struct ppc_link_hash_table *htab;
15489   bfd *dynobj;
15490   asection *sdyn;
15491
15492   htab = ppc_hash_table (info);
15493   if (htab == NULL)
15494     return FALSE;
15495
15496   dynobj = htab->elf.dynobj;
15497   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15498
15499   if (htab->elf.dynamic_sections_created)
15500     {
15501       Elf64_External_Dyn *dyncon, *dynconend;
15502
15503       if (sdyn == NULL || htab->elf.sgot == NULL)
15504         abort ();
15505
15506       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15507       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15508       for (; dyncon < dynconend; dyncon++)
15509         {
15510           Elf_Internal_Dyn dyn;
15511           asection *s;
15512
15513           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15514
15515           switch (dyn.d_tag)
15516             {
15517             default:
15518               continue;
15519
15520             case DT_PPC64_GLINK:
15521               s = htab->glink;
15522               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15523               /* We stupidly defined DT_PPC64_GLINK to be the start
15524                  of glink rather than the first entry point, which is
15525                  what ld.so needs, and now have a bigger stub to
15526                  support automatic multiple TOCs.  */
15527               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15528               break;
15529
15530             case DT_PPC64_OPD:
15531               s = bfd_get_section_by_name (output_bfd, ".opd");
15532               if (s == NULL)
15533                 continue;
15534               dyn.d_un.d_ptr = s->vma;
15535               break;
15536
15537             case DT_PPC64_OPT:
15538               if (htab->do_multi_toc && htab->multi_toc_needed)
15539                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15540               break;
15541
15542             case DT_PPC64_OPDSZ:
15543               s = bfd_get_section_by_name (output_bfd, ".opd");
15544               if (s == NULL)
15545                 continue;
15546               dyn.d_un.d_val = s->size;
15547               break;
15548
15549             case DT_PLTGOT:
15550               s = htab->elf.splt;
15551               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15552               break;
15553
15554             case DT_JMPREL:
15555               s = htab->elf.srelplt;
15556               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15557               break;
15558
15559             case DT_PLTRELSZ:
15560               dyn.d_un.d_val = htab->elf.srelplt->size;
15561               break;
15562             }
15563
15564           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15565         }
15566     }
15567
15568   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15569     {
15570       /* Fill in the first entry in the global offset table.
15571          We use it to hold the link-time TOCbase.  */
15572       bfd_put_64 (output_bfd,
15573                   elf_gp (output_bfd) + TOC_BASE_OFF,
15574                   htab->elf.sgot->contents);
15575
15576       /* Set .got entry size.  */
15577       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15578     }
15579
15580   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15581     {
15582       /* Set .plt entry size.  */
15583       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15584         = PLT_ENTRY_SIZE (htab);
15585     }
15586
15587   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15588      brlt ourselves if emitrelocations.  */
15589   if (htab->brlt != NULL
15590       && htab->brlt->reloc_count != 0
15591       && !_bfd_elf_link_output_relocs (output_bfd,
15592                                        htab->brlt,
15593                                        elf_section_data (htab->brlt)->rela.hdr,
15594                                        elf_section_data (htab->brlt)->relocs,
15595                                        NULL))
15596     return FALSE;
15597
15598   if (htab->glink != NULL
15599       && htab->glink->reloc_count != 0
15600       && !_bfd_elf_link_output_relocs (output_bfd,
15601                                        htab->glink,
15602                                        elf_section_data (htab->glink)->rela.hdr,
15603                                        elf_section_data (htab->glink)->relocs,
15604                                        NULL))
15605     return FALSE;
15606
15607   if (htab->glink_eh_frame != NULL
15608       && htab->glink_eh_frame->size != 0)
15609     {
15610       bfd_vma val;
15611       bfd_byte *p;
15612       asection *stub_sec;
15613
15614       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15615       for (stub_sec = htab->params->stub_bfd->sections;
15616            stub_sec != NULL;
15617            stub_sec = stub_sec->next)
15618         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15619           {
15620             /* FDE length.  */
15621             p += 4;
15622             /* CIE pointer.  */
15623             p += 4;
15624             /* Offset to stub section.  */
15625             val = (stub_sec->output_section->vma
15626                    + stub_sec->output_offset);
15627             val -= (htab->glink_eh_frame->output_section->vma
15628                     + htab->glink_eh_frame->output_offset
15629                     + (p - htab->glink_eh_frame->contents));
15630             if (val + 0x80000000 > 0xffffffff)
15631               {
15632                 info->callbacks->einfo
15633                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15634                    stub_sec->name);
15635                 return FALSE;
15636               }
15637             bfd_put_32 (dynobj, val, p);
15638             p += 4;
15639             /* stub section size.  */
15640             p += 4;
15641             /* Augmentation.  */
15642             p += 1;
15643             /* Pad.  */
15644             p += 7;
15645           }
15646       if (htab->glink != NULL && htab->glink->size != 0)
15647         {
15648           /* FDE length.  */
15649           p += 4;
15650           /* CIE pointer.  */
15651           p += 4;
15652           /* Offset to .glink.  */
15653           val = (htab->glink->output_section->vma
15654                  + htab->glink->output_offset
15655                  + 8);
15656           val -= (htab->glink_eh_frame->output_section->vma
15657                   + htab->glink_eh_frame->output_offset
15658                   + (p - htab->glink_eh_frame->contents));
15659           if (val + 0x80000000 > 0xffffffff)
15660             {
15661               info->callbacks->einfo
15662                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15663                  htab->glink->name);
15664               return FALSE;
15665             }
15666           bfd_put_32 (dynobj, val, p);
15667           p += 4;
15668           /* .glink size.  */
15669           p += 4;
15670           /* Augmentation.  */
15671           p += 1;
15672           /* Ops.  */
15673           p += 7;
15674         }
15675
15676       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15677           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15678                                                htab->glink_eh_frame,
15679                                                htab->glink_eh_frame->contents))
15680         return FALSE;
15681     }
15682
15683   /* We need to handle writing out multiple GOT sections ourselves,
15684      since we didn't add them to DYNOBJ.  We know dynobj is the first
15685      bfd.  */
15686   while ((dynobj = dynobj->link.next) != NULL)
15687     {
15688       asection *s;
15689
15690       if (!is_ppc64_elf (dynobj))
15691         continue;
15692
15693       s = ppc64_elf_tdata (dynobj)->got;
15694       if (s != NULL
15695           && s->size != 0
15696           && s->output_section != bfd_abs_section_ptr
15697           && !bfd_set_section_contents (output_bfd, s->output_section,
15698                                         s->contents, s->output_offset,
15699                                         s->size))
15700         return FALSE;
15701       s = ppc64_elf_tdata (dynobj)->relgot;
15702       if (s != NULL
15703           && s->size != 0
15704           && s->output_section != bfd_abs_section_ptr
15705           && !bfd_set_section_contents (output_bfd, s->output_section,
15706                                         s->contents, s->output_offset,
15707                                         s->size))
15708         return FALSE;
15709     }
15710
15711   return TRUE;
15712 }
15713
15714 #include "elf64-target.h"
15715
15716 /* FreeBSD support */
15717
15718 #undef  TARGET_LITTLE_SYM
15719 #undef  TARGET_LITTLE_NAME
15720
15721 #undef  TARGET_BIG_SYM
15722 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15723 #undef  TARGET_BIG_NAME
15724 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15725
15726 #undef  ELF_OSABI
15727 #define ELF_OSABI       ELFOSABI_FREEBSD
15728
15729 #undef  elf64_bed
15730 #define elf64_bed       elf64_powerpc_fbsd_bed
15731
15732 #include "elf64-target.h"
15733