bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2015 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_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  88 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  89
  90 #define elf_backend_object_p                  ppc64_elf_object_p
  91 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  92 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  93 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  94 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  95 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  96 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  97 #define elf_backend_check_directives          ppc64_elf_before_check_relocs
  98 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
  99 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 100 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 101 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 102 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 103 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 104 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 105 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 106 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 107 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 130
 131 /* Offsets to some stack save slots.  */
 132 #define STK_LR 16
 133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 134 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 135    CR save slot.  Used only by optimised __tls_get_addr call stub,
 136    relying on __tls_get_addr_opt not saving CR..  */
 137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 138
 139 /* TOC base pointers offset from start of TOC.  */
 140 #define TOC_BASE_OFF    0x8000
 141 /* TOC base alignment.  */
 142 #define TOC_BASE_ALIGN  256
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176
 177 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 178 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 179 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 180
 181 /* glink call stub instructions.  We enter with the index in R0.  */
 182 #define GLINK_CALL_STUB_SIZE (16*4)
 183                                         /* 0:                           */
 184                                         /*  .quad plt0-1f               */
 185                                         /* __glink:                     */
 186 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 187 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 188                                         /* 1:                           */
 189 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 190                                         /*  ld %2,(0b-1b)(%11)          */
 191 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 192 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 193                                         /*  ld %12,0(%11)               */
 194                                         /*  ld %2,8(%11)                */
 195                                         /*  mtctr %12                   */
 196                                         /*  ld %11,16(%11)              */
 197                                         /*  bctr                        */
 198 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 199 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 200 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 201 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 202 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 203
 204 /* Pad with this.  */
 205 #define NOP             0x60000000
 206
 207 /* Some other nops.  */
 208 #define CROR_151515     0x4def7b82
 209 #define CROR_313131     0x4ffffb82
 210
 211 /* .glink entries for the first 32k functions are two instructions.  */
 212 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 213 #define B_DOT           0x48000000      /* b     .              */
 214
 215 /* After that, we need two instructions to load the index, followed by
 216    a branch.  */
 217 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 218 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 219
 220 /* Instructions used by the save and restore reg functions.  */
 221 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 222 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 223 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 224 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 225 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 226 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 227 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 228 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 229 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 230 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 231 #define BLR             0x4e800020      /* blr                  */
 232
 233 /* Since .opd is an array of descriptors and each entry will end up
 234    with identical R_PPC64_RELATIVE relocs, there is really no need to
 235    propagate .opd relocs;  The dynamic linker should be taught to
 236    relocate .opd without reloc entries.  */
 237 #ifndef NO_OPD_RELOCS
 238 #define NO_OPD_RELOCS 0
 239 #endif
 240
 241 #ifndef ARRAY_SIZE
 242 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 243 #endif
 244
 245 static inline int
 246 abiversion (bfd *abfd)
 247 {
 248   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 249 }
 250
 251 static inline void
 252 set_abiversion (bfd *abfd, int ver)
 253 {
 254   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 255   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 256 }
 257 \f
 258 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 259
 260 /* Relocation HOWTO's.  */
 261 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 262
 263 static reloc_howto_type ppc64_elf_howto_raw[] = {
 264   /* This reloc does nothing.  */
 265   HOWTO (R_PPC64_NONE,          /* type */
 266          0,                     /* rightshift */
 267          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          0,                     /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_dont, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_NONE",        /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0,                     /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A standard 32 bit relocation.  */
 280   HOWTO (R_PPC64_ADDR32,        /* type */
 281          0,                     /* rightshift */
 282          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          32,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_bitfield, /* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR32",      /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffffffff,            /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* An absolute 26 bit branch; the lower two bits must be zero.
 295      FIXME: we don't check that, we just clear them.  */
 296   HOWTO (R_PPC64_ADDR24,        /* type */
 297          0,                     /* rightshift */
 298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 299          26,                    /* bitsize */
 300          FALSE,                 /* pc_relative */
 301          0,                     /* bitpos */
 302          complain_overflow_bitfield, /* complain_on_overflow */
 303          bfd_elf_generic_reloc, /* special_function */
 304          "R_PPC64_ADDR24",      /* name */
 305          FALSE,                 /* partial_inplace */
 306          0,                     /* src_mask */
 307          0x03fffffc,            /* dst_mask */
 308          FALSE),                /* pcrel_offset */
 309
 310   /* A standard 16 bit relocation.  */
 311   HOWTO (R_PPC64_ADDR16,        /* type */
 312          0,                     /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_bitfield, /* complain_on_overflow */
 318          bfd_elf_generic_reloc, /* special_function */
 319          "R_PPC64_ADDR16",      /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* A 16 bit relocation without overflow.  */
 326   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 327          0,                     /* rightshift */
 328          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 329          16,                    /* bitsize */
 330          FALSE,                 /* pc_relative */
 331          0,                     /* bitpos */
 332          complain_overflow_dont,/* complain_on_overflow */
 333          bfd_elf_generic_reloc, /* special_function */
 334          "R_PPC64_ADDR16_LO",   /* name */
 335          FALSE,                 /* partial_inplace */
 336          0,                     /* src_mask */
 337          0xffff,                /* dst_mask */
 338          FALSE),                /* pcrel_offset */
 339
 340   /* Bits 16-31 of an address.  */
 341   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 342          16,                    /* rightshift */
 343          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 344          16,                    /* bitsize */
 345          FALSE,                 /* pc_relative */
 346          0,                     /* bitpos */
 347          complain_overflow_signed, /* complain_on_overflow */
 348          bfd_elf_generic_reloc, /* special_function */
 349          "R_PPC64_ADDR16_HI",   /* name */
 350          FALSE,                 /* partial_inplace */
 351          0,                     /* src_mask */
 352          0xffff,                /* dst_mask */
 353          FALSE),                /* pcrel_offset */
 354
 355   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 356      bits, treated as a signed number, is negative.  */
 357   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 358          16,                    /* rightshift */
 359          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 360          16,                    /* bitsize */
 361          FALSE,                 /* pc_relative */
 362          0,                     /* bitpos */
 363          complain_overflow_signed, /* complain_on_overflow */
 364          ppc64_elf_ha_reloc,    /* special_function */
 365          "R_PPC64_ADDR16_HA",   /* name */
 366          FALSE,                 /* partial_inplace */
 367          0,                     /* src_mask */
 368          0xffff,                /* dst_mask */
 369          FALSE),                /* pcrel_offset */
 370
 371   /* An absolute 16 bit branch; the lower two bits must be zero.
 372      FIXME: we don't check that, we just clear them.  */
 373   HOWTO (R_PPC64_ADDR14,        /* type */
 374          0,                     /* rightshift */
 375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          16,                    /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_signed, /* complain_on_overflow */
 380          ppc64_elf_branch_reloc, /* special_function */
 381          "R_PPC64_ADDR14",      /* name */
 382          FALSE,                 /* partial_inplace */
 383          0,                     /* src_mask */
 384          0x0000fffc,            /* dst_mask */
 385          FALSE),                /* pcrel_offset */
 386
 387   /* An absolute 16 bit branch, for which bit 10 should be set to
 388      indicate that the branch is expected to be taken.  The lower two
 389      bits must be zero.  */
 390   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 391          0,                     /* rightshift */
 392          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 393          16,                    /* bitsize */
 394          FALSE,                 /* pc_relative */
 395          0,                     /* bitpos */
 396          complain_overflow_signed, /* complain_on_overflow */
 397          ppc64_elf_brtaken_reloc, /* special_function */
 398          "R_PPC64_ADDR14_BRTAKEN",/* name */
 399          FALSE,                 /* partial_inplace */
 400          0,                     /* src_mask */
 401          0x0000fffc,            /* dst_mask */
 402          FALSE),                /* pcrel_offset */
 403
 404   /* An absolute 16 bit branch, for which bit 10 should be set to
 405      indicate that the branch is not expected to be taken.  The lower
 406      two bits must be zero.  */
 407   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 408          0,                     /* rightshift */
 409          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          16,                    /* bitsize */
 411          FALSE,                 /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_signed, /* complain_on_overflow */
 414          ppc64_elf_brtaken_reloc, /* special_function */
 415          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 416          FALSE,                 /* partial_inplace */
 417          0,                     /* src_mask */
 418          0x0000fffc,            /* dst_mask */
 419          FALSE),                /* pcrel_offset */
 420
 421   /* A relative 26 bit branch; the lower two bits must be zero.  */
 422   HOWTO (R_PPC64_REL24,         /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          26,                    /* bitsize */
 426          TRUE,                  /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_signed, /* complain_on_overflow */
 429          ppc64_elf_branch_reloc, /* special_function */
 430          "R_PPC64_REL24",       /* name */
 431          FALSE,                 /* partial_inplace */
 432          0,                     /* src_mask */
 433          0x03fffffc,            /* dst_mask */
 434          TRUE),                 /* pcrel_offset */
 435
 436   /* A relative 16 bit branch; the lower two bits must be zero.  */
 437   HOWTO (R_PPC64_REL14,         /* type */
 438          0,                     /* rightshift */
 439          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 440          16,                    /* bitsize */
 441          TRUE,                  /* pc_relative */
 442          0,                     /* bitpos */
 443          complain_overflow_signed, /* complain_on_overflow */
 444          ppc64_elf_branch_reloc, /* special_function */
 445          "R_PPC64_REL14",       /* name */
 446          FALSE,                 /* partial_inplace */
 447          0,                     /* src_mask */
 448          0x0000fffc,            /* dst_mask */
 449          TRUE),                 /* pcrel_offset */
 450
 451   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 452      the branch is expected to be taken.  The lower two bits must be
 453      zero.  */
 454   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          16,                    /* bitsize */
 458          TRUE,                  /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_signed, /* complain_on_overflow */
 461          ppc64_elf_brtaken_reloc, /* special_function */
 462          "R_PPC64_REL14_BRTAKEN", /* name */
 463          FALSE,                 /* partial_inplace */
 464          0,                     /* src_mask */
 465          0x0000fffc,            /* dst_mask */
 466          TRUE),                 /* pcrel_offset */
 467
 468   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 469      the branch is not expected to be taken.  The lower two bits must
 470      be zero.  */
 471   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 472          0,                     /* rightshift */
 473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 474          16,                    /* bitsize */
 475          TRUE,                  /* pc_relative */
 476          0,                     /* bitpos */
 477          complain_overflow_signed, /* complain_on_overflow */
 478          ppc64_elf_brtaken_reloc, /* special_function */
 479          "R_PPC64_REL14_BRNTAKEN",/* name */
 480          FALSE,                 /* partial_inplace */
 481          0,                     /* src_mask */
 482          0x0000fffc,            /* dst_mask */
 483          TRUE),                 /* pcrel_offset */
 484
 485   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 486      symbol.  */
 487   HOWTO (R_PPC64_GOT16,         /* type */
 488          0,                     /* rightshift */
 489          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 490          16,                    /* bitsize */
 491          FALSE,                 /* pc_relative */
 492          0,                     /* bitpos */
 493          complain_overflow_signed, /* complain_on_overflow */
 494          ppc64_elf_unhandled_reloc, /* special_function */
 495          "R_PPC64_GOT16",       /* name */
 496          FALSE,                 /* partial_inplace */
 497          0,                     /* src_mask */
 498          0xffff,                /* dst_mask */
 499          FALSE),                /* pcrel_offset */
 500
 501   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 502      the symbol.  */
 503   HOWTO (R_PPC64_GOT16_LO,      /* type */
 504          0,                     /* rightshift */
 505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          16,                    /* bitsize */
 507          FALSE,                 /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_dont, /* complain_on_overflow */
 510          ppc64_elf_unhandled_reloc, /* special_function */
 511          "R_PPC64_GOT16_LO",    /* name */
 512          FALSE,                 /* partial_inplace */
 513          0,                     /* src_mask */
 514          0xffff,                /* dst_mask */
 515          FALSE),                /* pcrel_offset */
 516
 517   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 518      the symbol.  */
 519   HOWTO (R_PPC64_GOT16_HI,      /* type */
 520          16,                    /* rightshift */
 521          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 522          16,                    /* bitsize */
 523          FALSE,                 /* pc_relative */
 524          0,                     /* bitpos */
 525          complain_overflow_signed,/* complain_on_overflow */
 526          ppc64_elf_unhandled_reloc, /* special_function */
 527          "R_PPC64_GOT16_HI",    /* name */
 528          FALSE,                 /* partial_inplace */
 529          0,                     /* src_mask */
 530          0xffff,                /* dst_mask */
 531          FALSE),                /* pcrel_offset */
 532
 533   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 534      the symbol.  */
 535   HOWTO (R_PPC64_GOT16_HA,      /* type */
 536          16,                    /* rightshift */
 537          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 538          16,                    /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_signed,/* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc, /* special_function */
 543          "R_PPC64_GOT16_HA",    /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          0xffff,                /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* This is used only by the dynamic linker.  The symbol should exist
 550      both in the object being run and in some shared library.  The
 551      dynamic linker copies the data addressed by the symbol from the
 552      shared library into the object, because the object being
 553      run has to have the data at some particular address.  */
 554   HOWTO (R_PPC64_COPY,          /* type */
 555          0,                     /* rightshift */
 556          0,                     /* this one is variable size */
 557          0,                     /* bitsize */
 558          FALSE,                 /* pc_relative */
 559          0,                     /* bitpos */
 560          complain_overflow_dont, /* complain_on_overflow */
 561          ppc64_elf_unhandled_reloc, /* special_function */
 562          "R_PPC64_COPY",        /* name */
 563          FALSE,                 /* partial_inplace */
 564          0,                     /* src_mask */
 565          0,                     /* dst_mask */
 566          FALSE),                /* pcrel_offset */
 567
 568   /* Like R_PPC64_ADDR64, but used when setting global offset table
 569      entries.  */
 570   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 571          0,                     /* rightshift */
 572          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 573          64,                    /* bitsize */
 574          FALSE,                 /* pc_relative */
 575          0,                     /* bitpos */
 576          complain_overflow_dont, /* complain_on_overflow */
 577          ppc64_elf_unhandled_reloc,  /* special_function */
 578          "R_PPC64_GLOB_DAT",    /* name */
 579          FALSE,                 /* partial_inplace */
 580          0,                     /* src_mask */
 581          ONES (64),             /* dst_mask */
 582          FALSE),                /* pcrel_offset */
 583
 584   /* Created by the link editor.  Marks a procedure linkage table
 585      entry for a symbol.  */
 586   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 587          0,                     /* rightshift */
 588          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 589          0,                     /* bitsize */
 590          FALSE,                 /* pc_relative */
 591          0,                     /* bitpos */
 592          complain_overflow_dont, /* complain_on_overflow */
 593          ppc64_elf_unhandled_reloc, /* special_function */
 594          "R_PPC64_JMP_SLOT",    /* name */
 595          FALSE,                 /* partial_inplace */
 596          0,                     /* src_mask */
 597          0,                     /* dst_mask */
 598          FALSE),                /* pcrel_offset */
 599
 600   /* Used only by the dynamic linker.  When the object is run, this
 601      doubleword64 is set to the load address of the object, plus the
 602      addend.  */
 603   HOWTO (R_PPC64_RELATIVE,      /* type */
 604          0,                     /* rightshift */
 605          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 606          64,                    /* bitsize */
 607          FALSE,                 /* pc_relative */
 608          0,                     /* bitpos */
 609          complain_overflow_dont, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_RELATIVE",    /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          ONES (64),             /* dst_mask */
 615          FALSE),                /* pcrel_offset */
 616
 617   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 618   HOWTO (R_PPC64_UADDR32,       /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          bfd_elf_generic_reloc, /* special_function */
 626          "R_PPC64_UADDR32",     /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 633   HOWTO (R_PPC64_UADDR16,       /* type */
 634          0,                     /* rightshift */
 635          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 636          16,                    /* bitsize */
 637          FALSE,                 /* pc_relative */
 638          0,                     /* bitpos */
 639          complain_overflow_bitfield, /* complain_on_overflow */
 640          bfd_elf_generic_reloc, /* special_function */
 641          "R_PPC64_UADDR16",     /* name */
 642          FALSE,                 /* partial_inplace */
 643          0,                     /* src_mask */
 644          0xffff,                /* dst_mask */
 645          FALSE),                /* pcrel_offset */
 646
 647   /* 32-bit PC relative.  */
 648   HOWTO (R_PPC64_REL32,         /* type */
 649          0,                     /* rightshift */
 650          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 651          32,                    /* bitsize */
 652          TRUE,                  /* pc_relative */
 653          0,                     /* bitpos */
 654          complain_overflow_signed, /* complain_on_overflow */
 655          bfd_elf_generic_reloc, /* special_function */
 656          "R_PPC64_REL32",       /* name */
 657          FALSE,                 /* partial_inplace */
 658          0,                     /* src_mask */
 659          0xffffffff,            /* dst_mask */
 660          TRUE),                 /* pcrel_offset */
 661
 662   /* 32-bit relocation to the symbol's procedure linkage table.  */
 663   HOWTO (R_PPC64_PLT32,         /* type */
 664          0,                     /* rightshift */
 665          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 666          32,                    /* bitsize */
 667          FALSE,                 /* pc_relative */
 668          0,                     /* bitpos */
 669          complain_overflow_bitfield, /* complain_on_overflow */
 670          ppc64_elf_unhandled_reloc, /* special_function */
 671          "R_PPC64_PLT32",       /* name */
 672          FALSE,                 /* partial_inplace */
 673          0,                     /* src_mask */
 674          0xffffffff,            /* dst_mask */
 675          FALSE),                /* pcrel_offset */
 676
 677   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 678      FIXME: R_PPC64_PLTREL32 not supported.  */
 679   HOWTO (R_PPC64_PLTREL32,      /* type */
 680          0,                     /* rightshift */
 681          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 682          32,                    /* bitsize */
 683          TRUE,                  /* pc_relative */
 684          0,                     /* bitpos */
 685          complain_overflow_signed, /* complain_on_overflow */
 686          bfd_elf_generic_reloc, /* special_function */
 687          "R_PPC64_PLTREL32",    /* name */
 688          FALSE,                 /* partial_inplace */
 689          0,                     /* src_mask */
 690          0xffffffff,            /* dst_mask */
 691          TRUE),                 /* pcrel_offset */
 692
 693   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 694      the symbol.  */
 695   HOWTO (R_PPC64_PLT16_LO,      /* type */
 696          0,                     /* rightshift */
 697          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 698          16,                    /* bitsize */
 699          FALSE,                 /* pc_relative */
 700          0,                     /* bitpos */
 701          complain_overflow_dont, /* complain_on_overflow */
 702          ppc64_elf_unhandled_reloc, /* special_function */
 703          "R_PPC64_PLT16_LO",    /* name */
 704          FALSE,                 /* partial_inplace */
 705          0,                     /* src_mask */
 706          0xffff,                /* dst_mask */
 707          FALSE),                /* pcrel_offset */
 708
 709   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 710      the symbol.  */
 711   HOWTO (R_PPC64_PLT16_HI,      /* type */
 712          16,                    /* rightshift */
 713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 714          16,                    /* bitsize */
 715          FALSE,                 /* pc_relative */
 716          0,                     /* bitpos */
 717          complain_overflow_signed, /* complain_on_overflow */
 718          ppc64_elf_unhandled_reloc, /* special_function */
 719          "R_PPC64_PLT16_HI",    /* name */
 720          FALSE,                 /* partial_inplace */
 721          0,                     /* src_mask */
 722          0xffff,                /* dst_mask */
 723          FALSE),                /* pcrel_offset */
 724
 725   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 726      the symbol.  */
 727   HOWTO (R_PPC64_PLT16_HA,      /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_signed, /* complain_on_overflow */
 734          ppc64_elf_unhandled_reloc, /* special_function */
 735          "R_PPC64_PLT16_HA",    /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF,       /* type */
 743          0,                     /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_signed, /* complain_on_overflow */
 749          ppc64_elf_sectoff_reloc, /* special_function */
 750          "R_PPC64_SECTOFF",     /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 757   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 758          0,                     /* rightshift */
 759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          16,                    /* bitsize */
 761          FALSE,                 /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          ppc64_elf_sectoff_reloc, /* special_function */
 765          "R_PPC64_SECTOFF_LO",  /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xffff,                /* dst_mask */
 769          FALSE),                /* pcrel_offset */
 770
 771   /* 16-bit upper half section relative relocation.  */
 772   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 773          16,                    /* rightshift */
 774          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 775          16,                    /* bitsize */
 776          FALSE,                 /* pc_relative */
 777          0,                     /* bitpos */
 778          complain_overflow_signed, /* complain_on_overflow */
 779          ppc64_elf_sectoff_reloc, /* special_function */
 780          "R_PPC64_SECTOFF_HI",  /* name */
 781          FALSE,                 /* partial_inplace */
 782          0,                     /* src_mask */
 783          0xffff,                /* dst_mask */
 784          FALSE),                /* pcrel_offset */
 785
 786   /* 16-bit upper half adjusted section relative relocation.  */
 787   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 788          16,                    /* rightshift */
 789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 790          16,                    /* bitsize */
 791          FALSE,                 /* pc_relative */
 792          0,                     /* bitpos */
 793          complain_overflow_signed, /* complain_on_overflow */
 794          ppc64_elf_sectoff_ha_reloc, /* special_function */
 795          "R_PPC64_SECTOFF_HA",  /* name */
 796          FALSE,                 /* partial_inplace */
 797          0,                     /* src_mask */
 798          0xffff,                /* dst_mask */
 799          FALSE),                /* pcrel_offset */
 800
 801   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 802   HOWTO (R_PPC64_REL30,         /* type */
 803          2,                     /* rightshift */
 804          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 805          30,                    /* bitsize */
 806          TRUE,                  /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_dont, /* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_PPC64_REL30",       /* name */
 811          FALSE,                 /* partial_inplace */
 812          0,                     /* src_mask */
 813          0xfffffffc,            /* dst_mask */
 814          TRUE),                 /* pcrel_offset */
 815
 816   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 817
 818   /* A standard 64-bit relocation.  */
 819   HOWTO (R_PPC64_ADDR64,        /* type */
 820          0,                     /* rightshift */
 821          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 822          64,                    /* bitsize */
 823          FALSE,                 /* pc_relative */
 824          0,                     /* bitpos */
 825          complain_overflow_dont, /* complain_on_overflow */
 826          bfd_elf_generic_reloc, /* special_function */
 827          "R_PPC64_ADDR64",      /* name */
 828          FALSE,                 /* partial_inplace */
 829          0,                     /* src_mask */
 830          ONES (64),             /* dst_mask */
 831          FALSE),                /* pcrel_offset */
 832
 833   /* The bits 32-47 of an address.  */
 834   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 835          32,                    /* rightshift */
 836          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 837          16,                    /* bitsize */
 838          FALSE,                 /* pc_relative */
 839          0,                     /* bitpos */
 840          complain_overflow_dont, /* complain_on_overflow */
 841          bfd_elf_generic_reloc, /* special_function */
 842          "R_PPC64_ADDR16_HIGHER", /* name */
 843          FALSE,                 /* partial_inplace */
 844          0,                     /* src_mask */
 845          0xffff,                /* dst_mask */
 846          FALSE),                /* pcrel_offset */
 847
 848   /* The bits 32-47 of an address, plus 1 if the contents of the low
 849      16 bits, treated as a signed number, is negative.  */
 850   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 851          32,                    /* rightshift */
 852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 853          16,                    /* bitsize */
 854          FALSE,                 /* pc_relative */
 855          0,                     /* bitpos */
 856          complain_overflow_dont, /* complain_on_overflow */
 857          ppc64_elf_ha_reloc,    /* special_function */
 858          "R_PPC64_ADDR16_HIGHERA", /* name */
 859          FALSE,                 /* partial_inplace */
 860          0,                     /* src_mask */
 861          0xffff,                /* dst_mask */
 862          FALSE),                /* pcrel_offset */
 863
 864   /* The bits 48-63 of an address.  */
 865   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 866          48,                    /* rightshift */
 867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 868          16,                    /* bitsize */
 869          FALSE,                 /* pc_relative */
 870          0,                     /* bitpos */
 871          complain_overflow_dont, /* complain_on_overflow */
 872          bfd_elf_generic_reloc, /* special_function */
 873          "R_PPC64_ADDR16_HIGHEST", /* name */
 874          FALSE,                 /* partial_inplace */
 875          0,                     /* src_mask */
 876          0xffff,                /* dst_mask */
 877          FALSE),                /* pcrel_offset */
 878
 879   /* The bits 48-63 of an address, plus 1 if the contents of the low
 880      16 bits, treated as a signed number, is negative.  */
 881   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 882          48,                    /* rightshift */
 883          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 884          16,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_ha_reloc,    /* special_function */
 889          "R_PPC64_ADDR16_HIGHESTA", /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          0xffff,                /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* Like ADDR64, but may be unaligned.  */
 896   HOWTO (R_PPC64_UADDR64,       /* type */
 897          0,                     /* rightshift */
 898          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 899          64,                    /* bitsize */
 900          FALSE,                 /* pc_relative */
 901          0,                     /* bitpos */
 902          complain_overflow_dont, /* complain_on_overflow */
 903          bfd_elf_generic_reloc, /* special_function */
 904          "R_PPC64_UADDR64",     /* name */
 905          FALSE,                 /* partial_inplace */
 906          0,                     /* src_mask */
 907          ONES (64),             /* dst_mask */
 908          FALSE),                /* pcrel_offset */
 909
 910   /* 64-bit relative relocation.  */
 911   HOWTO (R_PPC64_REL64,         /* type */
 912          0,                     /* rightshift */
 913          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 914          64,                    /* bitsize */
 915          TRUE,                  /* pc_relative */
 916          0,                     /* bitpos */
 917          complain_overflow_dont, /* complain_on_overflow */
 918          bfd_elf_generic_reloc, /* special_function */
 919          "R_PPC64_REL64",       /* name */
 920          FALSE,                 /* partial_inplace */
 921          0,                     /* src_mask */
 922          ONES (64),             /* dst_mask */
 923          TRUE),                 /* pcrel_offset */
 924
 925   /* 64-bit relocation to the symbol's procedure linkage table.  */
 926   HOWTO (R_PPC64_PLT64,         /* type */
 927          0,                     /* rightshift */
 928          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 929          64,                    /* bitsize */
 930          FALSE,                 /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_dont, /* complain_on_overflow */
 933          ppc64_elf_unhandled_reloc, /* special_function */
 934          "R_PPC64_PLT64",       /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          ONES (64),             /* dst_mask */
 938          FALSE),                /* pcrel_offset */
 939
 940   /* 64-bit PC relative relocation to the symbol's procedure linkage
 941      table.  */
 942   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 943   HOWTO (R_PPC64_PLTREL64,      /* type */
 944          0,                     /* rightshift */
 945          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 946          64,                    /* bitsize */
 947          TRUE,                  /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_dont, /* complain_on_overflow */
 950          ppc64_elf_unhandled_reloc, /* special_function */
 951          "R_PPC64_PLTREL64",    /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          ONES (64),             /* dst_mask */
 955          TRUE),                 /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation.  */
 958
 959   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 960   HOWTO (R_PPC64_TOC16,         /* type */
 961          0,                     /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_signed, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16",       /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation without overflow.  */
 975
 976   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 977   HOWTO (R_PPC64_TOC16_LO,      /* type */
 978          0,                     /* rightshift */
 979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          16,                    /* bitsize */
 981          FALSE,                 /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_dont, /* complain_on_overflow */
 984          ppc64_elf_toc_reloc,   /* special_function */
 985          "R_PPC64_TOC16_LO",    /* name */
 986          FALSE,                 /* partial_inplace */
 987          0,                     /* src_mask */
 988          0xffff,                /* dst_mask */
 989          FALSE),                /* pcrel_offset */
 990
 991   /* 16 bit TOC-relative relocation, high 16 bits.  */
 992
 993   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 994   HOWTO (R_PPC64_TOC16_HI,      /* type */
 995          16,                    /* rightshift */
 996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 997          16,                    /* bitsize */
 998          FALSE,                 /* pc_relative */
 999          0,                     /* bitpos */
1000          complain_overflow_signed, /* complain_on_overflow */
1001          ppc64_elf_toc_reloc,   /* special_function */
1002          "R_PPC64_TOC16_HI",    /* name */
1003          FALSE,                 /* partial_inplace */
1004          0,                     /* src_mask */
1005          0xffff,                /* dst_mask */
1006          FALSE),                /* pcrel_offset */
1007
1008   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1009      contents of the low 16 bits, treated as a signed number, is
1010      negative.  */
1011
1012   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1013   HOWTO (R_PPC64_TOC16_HA,      /* type */
1014          16,                    /* rightshift */
1015          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1016          16,                    /* bitsize */
1017          FALSE,                 /* pc_relative */
1018          0,                     /* bitpos */
1019          complain_overflow_signed, /* complain_on_overflow */
1020          ppc64_elf_toc_ha_reloc, /* special_function */
1021          "R_PPC64_TOC16_HA",    /* name */
1022          FALSE,                 /* partial_inplace */
1023          0,                     /* src_mask */
1024          0xffff,                /* dst_mask */
1025          FALSE),                /* pcrel_offset */
1026
1027   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1028
1029   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1030   HOWTO (R_PPC64_TOC,           /* type */
1031          0,                     /* rightshift */
1032          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1033          64,                    /* bitsize */
1034          FALSE,                 /* pc_relative */
1035          0,                     /* bitpos */
1036          complain_overflow_dont, /* complain_on_overflow */
1037          ppc64_elf_toc64_reloc, /* special_function */
1038          "R_PPC64_TOC",         /* name */
1039          FALSE,                 /* partial_inplace */
1040          0,                     /* src_mask */
1041          ONES (64),             /* dst_mask */
1042          FALSE),                /* pcrel_offset */
1043
1044   /* Like R_PPC64_GOT16, but also informs the link editor that the
1045      value to relocate may (!) refer to a PLT entry which the link
1046      editor (a) may replace with the symbol value.  If the link editor
1047      is unable to fully resolve the symbol, it may (b) create a PLT
1048      entry and store the address to the new PLT entry in the GOT.
1049      This permits lazy resolution of function symbols at run time.
1050      The link editor may also skip all of this and just (c) emit a
1051      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1052   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1053     HOWTO (R_PPC64_PLTGOT16,    /* type */
1054          0,                     /* rightshift */
1055          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1056          16,                    /* bitsize */
1057          FALSE,                 /* pc_relative */
1058          0,                     /* bitpos */
1059          complain_overflow_signed, /* complain_on_overflow */
1060          ppc64_elf_unhandled_reloc, /* special_function */
1061          "R_PPC64_PLTGOT16",    /* name */
1062          FALSE,                 /* partial_inplace */
1063          0,                     /* src_mask */
1064          0xffff,                /* dst_mask */
1065          FALSE),                /* pcrel_offset */
1066
1067   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1068   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1069   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1070          0,                     /* rightshift */
1071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1072          16,                    /* bitsize */
1073          FALSE,                 /* pc_relative */
1074          0,                     /* bitpos */
1075          complain_overflow_dont, /* complain_on_overflow */
1076          ppc64_elf_unhandled_reloc, /* special_function */
1077          "R_PPC64_PLTGOT16_LO", /* name */
1078          FALSE,                 /* partial_inplace */
1079          0,                     /* src_mask */
1080          0xffff,                /* dst_mask */
1081          FALSE),                /* pcrel_offset */
1082
1083   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1084   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1085   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1086          16,                    /* rightshift */
1087          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1088          16,                    /* bitsize */
1089          FALSE,                 /* pc_relative */
1090          0,                     /* bitpos */
1091          complain_overflow_signed, /* complain_on_overflow */
1092          ppc64_elf_unhandled_reloc, /* special_function */
1093          "R_PPC64_PLTGOT16_HI", /* name */
1094          FALSE,                 /* partial_inplace */
1095          0,                     /* src_mask */
1096          0xffff,                /* dst_mask */
1097          FALSE),                /* pcrel_offset */
1098
1099   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1100      1 if the contents of the low 16 bits, treated as a signed number,
1101      is negative.  */
1102   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1103   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1104          16,                    /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_PLTGOT16_HA", /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xffff,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_signed, /* complain_on_overflow */
1125          bfd_elf_generic_reloc, /* special_function */
1126          "R_PPC64_ADDR16_DS",   /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont,/* complain_on_overflow */
1140          bfd_elf_generic_reloc, /* special_function */
1141          "R_PPC64_ADDR16_LO_DS",/* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_GOT16_DS,      /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_signed, /* complain_on_overflow */
1155          ppc64_elf_unhandled_reloc, /* special_function */
1156          "R_PPC64_GOT16_DS",    /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_unhandled_reloc, /* special_function */
1171          "R_PPC64_GOT16_LO_DS", /* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_dont, /* complain_on_overflow */
1185          ppc64_elf_unhandled_reloc, /* special_function */
1186          "R_PPC64_PLT16_LO_DS", /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_signed, /* complain_on_overflow */
1200          ppc64_elf_sectoff_reloc, /* special_function */
1201          "R_PPC64_SECTOFF_DS",  /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1208   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1209          0,                     /* rightshift */
1210          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1211          16,                    /* bitsize */
1212          FALSE,                 /* pc_relative */
1213          0,                     /* bitpos */
1214          complain_overflow_dont, /* complain_on_overflow */
1215          ppc64_elf_sectoff_reloc, /* special_function */
1216          "R_PPC64_SECTOFF_LO_DS",/* name */
1217          FALSE,                 /* partial_inplace */
1218          0,                     /* src_mask */
1219          0xfffc,                /* dst_mask */
1220          FALSE),                /* pcrel_offset */
1221
1222   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1223   HOWTO (R_PPC64_TOC16_DS,      /* type */
1224          0,                     /* rightshift */
1225          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1226          16,                    /* bitsize */
1227          FALSE,                 /* pc_relative */
1228          0,                     /* bitpos */
1229          complain_overflow_signed, /* complain_on_overflow */
1230          ppc64_elf_toc_reloc,   /* special_function */
1231          "R_PPC64_TOC16_DS",    /* name */
1232          FALSE,                 /* partial_inplace */
1233          0,                     /* src_mask */
1234          0xfffc,                /* dst_mask */
1235          FALSE),                /* pcrel_offset */
1236
1237   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1238   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1239          0,                     /* rightshift */
1240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1241          16,                    /* bitsize */
1242          FALSE,                 /* pc_relative */
1243          0,                     /* bitpos */
1244          complain_overflow_dont, /* complain_on_overflow */
1245          ppc64_elf_toc_reloc,   /* special_function */
1246          "R_PPC64_TOC16_LO_DS", /* name */
1247          FALSE,                 /* partial_inplace */
1248          0,                     /* src_mask */
1249          0xfffc,                /* dst_mask */
1250          FALSE),                /* pcrel_offset */
1251
1252   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1253   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1254   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1255          0,                     /* rightshift */
1256          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          16,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_signed, /* complain_on_overflow */
1261          ppc64_elf_unhandled_reloc, /* special_function */
1262          "R_PPC64_PLTGOT16_DS", /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0xfffc,                /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1269   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1270   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1271          0,                     /* rightshift */
1272          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1273          16,                    /* bitsize */
1274          FALSE,                 /* pc_relative */
1275          0,                     /* bitpos */
1276          complain_overflow_dont, /* complain_on_overflow */
1277          ppc64_elf_unhandled_reloc, /* special_function */
1278          "R_PPC64_PLTGOT16_LO_DS",/* name */
1279          FALSE,                 /* partial_inplace */
1280          0,                     /* src_mask */
1281          0xfffc,                /* dst_mask */
1282          FALSE),                /* pcrel_offset */
1283
1284   /* Marker relocs for TLS.  */
1285   HOWTO (R_PPC64_TLS,
1286          0,                     /* rightshift */
1287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1288          32,                    /* bitsize */
1289          FALSE,                 /* pc_relative */
1290          0,                     /* bitpos */
1291          complain_overflow_dont, /* complain_on_overflow */
1292          bfd_elf_generic_reloc, /* special_function */
1293          "R_PPC64_TLS",         /* name */
1294          FALSE,                 /* partial_inplace */
1295          0,                     /* src_mask */
1296          0,                     /* dst_mask */
1297          FALSE),                /* pcrel_offset */
1298
1299   HOWTO (R_PPC64_TLSGD,
1300          0,                     /* rightshift */
1301          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1302          32,                    /* bitsize */
1303          FALSE,                 /* pc_relative */
1304          0,                     /* bitpos */
1305          complain_overflow_dont, /* complain_on_overflow */
1306          bfd_elf_generic_reloc, /* special_function */
1307          "R_PPC64_TLSGD",       /* name */
1308          FALSE,                 /* partial_inplace */
1309          0,                     /* src_mask */
1310          0,                     /* dst_mask */
1311          FALSE),                /* pcrel_offset */
1312
1313   HOWTO (R_PPC64_TLSLD,
1314          0,                     /* rightshift */
1315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          32,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          0,                     /* bitpos */
1319          complain_overflow_dont, /* complain_on_overflow */
1320          bfd_elf_generic_reloc, /* special_function */
1321          "R_PPC64_TLSLD",       /* name */
1322          FALSE,                 /* partial_inplace */
1323          0,                     /* src_mask */
1324          0,                     /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   HOWTO (R_PPC64_TOCSAVE,
1328          0,                     /* rightshift */
1329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1330          32,                    /* bitsize */
1331          FALSE,                 /* pc_relative */
1332          0,                     /* bitpos */
1333          complain_overflow_dont, /* complain_on_overflow */
1334          bfd_elf_generic_reloc, /* special_function */
1335          "R_PPC64_TOCSAVE",     /* name */
1336          FALSE,                 /* partial_inplace */
1337          0,                     /* src_mask */
1338          0,                     /* dst_mask */
1339          FALSE),                /* pcrel_offset */
1340
1341   /* Computes the load module index of the load module that contains the
1342      definition of its TLS sym.  */
1343   HOWTO (R_PPC64_DTPMOD64,
1344          0,                     /* rightshift */
1345          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          64,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont, /* complain_on_overflow */
1350          ppc64_elf_unhandled_reloc, /* special_function */
1351          "R_PPC64_DTPMOD64",    /* name */
1352          FALSE,                 /* partial_inplace */
1353          0,                     /* src_mask */
1354          ONES (64),             /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* Computes a dtv-relative displacement, the difference between the value
1358      of sym+add and the base address of the thread-local storage block that
1359      contains the definition of sym, minus 0x8000.  */
1360   HOWTO (R_PPC64_DTPREL64,
1361          0,                     /* rightshift */
1362          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1363          64,                    /* bitsize */
1364          FALSE,                 /* pc_relative */
1365          0,                     /* bitpos */
1366          complain_overflow_dont, /* complain_on_overflow */
1367          ppc64_elf_unhandled_reloc, /* special_function */
1368          "R_PPC64_DTPREL64",    /* name */
1369          FALSE,                 /* partial_inplace */
1370          0,                     /* src_mask */
1371          ONES (64),             /* dst_mask */
1372          FALSE),                /* pcrel_offset */
1373
1374   /* A 16 bit dtprel reloc.  */
1375   HOWTO (R_PPC64_DTPREL16,
1376          0,                     /* rightshift */
1377          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1378          16,                    /* bitsize */
1379          FALSE,                 /* pc_relative */
1380          0,                     /* bitpos */
1381          complain_overflow_signed, /* complain_on_overflow */
1382          ppc64_elf_unhandled_reloc, /* special_function */
1383          "R_PPC64_DTPREL16",    /* name */
1384          FALSE,                 /* partial_inplace */
1385          0,                     /* src_mask */
1386          0xffff,                /* dst_mask */
1387          FALSE),                /* pcrel_offset */
1388
1389   /* Like DTPREL16, but no overflow.  */
1390   HOWTO (R_PPC64_DTPREL16_LO,
1391          0,                     /* rightshift */
1392          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1393          16,                    /* bitsize */
1394          FALSE,                 /* pc_relative */
1395          0,                     /* bitpos */
1396          complain_overflow_dont, /* complain_on_overflow */
1397          ppc64_elf_unhandled_reloc, /* special_function */
1398          "R_PPC64_DTPREL16_LO", /* name */
1399          FALSE,                 /* partial_inplace */
1400          0,                     /* src_mask */
1401          0xffff,                /* dst_mask */
1402          FALSE),                /* pcrel_offset */
1403
1404   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1405   HOWTO (R_PPC64_DTPREL16_HI,
1406          16,                    /* rightshift */
1407          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1408          16,                    /* bitsize */
1409          FALSE,                 /* pc_relative */
1410          0,                     /* bitpos */
1411          complain_overflow_signed, /* complain_on_overflow */
1412          ppc64_elf_unhandled_reloc, /* special_function */
1413          "R_PPC64_DTPREL16_HI", /* name */
1414          FALSE,                 /* partial_inplace */
1415          0,                     /* src_mask */
1416          0xffff,                /* dst_mask */
1417          FALSE),                /* pcrel_offset */
1418
1419   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1420   HOWTO (R_PPC64_DTPREL16_HA,
1421          16,                    /* rightshift */
1422          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1423          16,                    /* bitsize */
1424          FALSE,                 /* pc_relative */
1425          0,                     /* bitpos */
1426          complain_overflow_signed, /* complain_on_overflow */
1427          ppc64_elf_unhandled_reloc, /* special_function */
1428          "R_PPC64_DTPREL16_HA", /* name */
1429          FALSE,                 /* partial_inplace */
1430          0,                     /* src_mask */
1431          0xffff,                /* dst_mask */
1432          FALSE),                /* pcrel_offset */
1433
1434   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1435   HOWTO (R_PPC64_DTPREL16_HIGHER,
1436          32,                    /* rightshift */
1437          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1438          16,                    /* bitsize */
1439          FALSE,                 /* pc_relative */
1440          0,                     /* bitpos */
1441          complain_overflow_dont, /* complain_on_overflow */
1442          ppc64_elf_unhandled_reloc, /* special_function */
1443          "R_PPC64_DTPREL16_HIGHER", /* name */
1444          FALSE,                 /* partial_inplace */
1445          0,                     /* src_mask */
1446          0xffff,                /* dst_mask */
1447          FALSE),                /* pcrel_offset */
1448
1449   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1450   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1451          32,                    /* rightshift */
1452          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1453          16,                    /* bitsize */
1454          FALSE,                 /* pc_relative */
1455          0,                     /* bitpos */
1456          complain_overflow_dont, /* complain_on_overflow */
1457          ppc64_elf_unhandled_reloc, /* special_function */
1458          "R_PPC64_DTPREL16_HIGHERA", /* name */
1459          FALSE,                 /* partial_inplace */
1460          0,                     /* src_mask */
1461          0xffff,                /* dst_mask */
1462          FALSE),                /* pcrel_offset */
1463
1464   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1465   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1466          48,                    /* rightshift */
1467          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1468          16,                    /* bitsize */
1469          FALSE,                 /* pc_relative */
1470          0,                     /* bitpos */
1471          complain_overflow_dont, /* complain_on_overflow */
1472          ppc64_elf_unhandled_reloc, /* special_function */
1473          "R_PPC64_DTPREL16_HIGHEST", /* name */
1474          FALSE,                 /* partial_inplace */
1475          0,                     /* src_mask */
1476          0xffff,                /* dst_mask */
1477          FALSE),                /* pcrel_offset */
1478
1479   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1480   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1481          48,                    /* rightshift */
1482          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1483          16,                    /* bitsize */
1484          FALSE,                 /* pc_relative */
1485          0,                     /* bitpos */
1486          complain_overflow_dont, /* complain_on_overflow */
1487          ppc64_elf_unhandled_reloc, /* special_function */
1488          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1489          FALSE,                 /* partial_inplace */
1490          0,                     /* src_mask */
1491          0xffff,                /* dst_mask */
1492          FALSE),                /* pcrel_offset */
1493
1494   /* Like DTPREL16, but for insns with a DS field.  */
1495   HOWTO (R_PPC64_DTPREL16_DS,
1496          0,                     /* rightshift */
1497          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1498          16,                    /* bitsize */
1499          FALSE,                 /* pc_relative */
1500          0,                     /* bitpos */
1501          complain_overflow_signed, /* complain_on_overflow */
1502          ppc64_elf_unhandled_reloc, /* special_function */
1503          "R_PPC64_DTPREL16_DS", /* name */
1504          FALSE,                 /* partial_inplace */
1505          0,                     /* src_mask */
1506          0xfffc,                /* dst_mask */
1507          FALSE),                /* pcrel_offset */
1508
1509   /* Like DTPREL16_DS, but no overflow.  */
1510   HOWTO (R_PPC64_DTPREL16_LO_DS,
1511          0,                     /* rightshift */
1512          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1513          16,                    /* bitsize */
1514          FALSE,                 /* pc_relative */
1515          0,                     /* bitpos */
1516          complain_overflow_dont, /* complain_on_overflow */
1517          ppc64_elf_unhandled_reloc, /* special_function */
1518          "R_PPC64_DTPREL16_LO_DS", /* name */
1519          FALSE,                 /* partial_inplace */
1520          0,                     /* src_mask */
1521          0xfffc,                /* dst_mask */
1522          FALSE),                /* pcrel_offset */
1523
1524   /* Computes a tp-relative displacement, the difference between the value of
1525      sym+add and the value of the thread pointer (r13).  */
1526   HOWTO (R_PPC64_TPREL64,
1527          0,                     /* rightshift */
1528          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1529          64,                    /* bitsize */
1530          FALSE,                 /* pc_relative */
1531          0,                     /* bitpos */
1532          complain_overflow_dont, /* complain_on_overflow */
1533          ppc64_elf_unhandled_reloc, /* special_function */
1534          "R_PPC64_TPREL64",     /* name */
1535          FALSE,                 /* partial_inplace */
1536          0,                     /* src_mask */
1537          ONES (64),             /* dst_mask */
1538          FALSE),                /* pcrel_offset */
1539
1540   /* A 16 bit tprel reloc.  */
1541   HOWTO (R_PPC64_TPREL16,
1542          0,                     /* rightshift */
1543          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1544          16,                    /* bitsize */
1545          FALSE,                 /* pc_relative */
1546          0,                     /* bitpos */
1547          complain_overflow_signed, /* complain_on_overflow */
1548          ppc64_elf_unhandled_reloc, /* special_function */
1549          "R_PPC64_TPREL16",     /* name */
1550          FALSE,                 /* partial_inplace */
1551          0,                     /* src_mask */
1552          0xffff,                /* dst_mask */
1553          FALSE),                /* pcrel_offset */
1554
1555   /* Like TPREL16, but no overflow.  */
1556   HOWTO (R_PPC64_TPREL16_LO,
1557          0,                     /* rightshift */
1558          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1559          16,                    /* bitsize */
1560          FALSE,                 /* pc_relative */
1561          0,                     /* bitpos */
1562          complain_overflow_dont, /* complain_on_overflow */
1563          ppc64_elf_unhandled_reloc, /* special_function */
1564          "R_PPC64_TPREL16_LO",  /* name */
1565          FALSE,                 /* partial_inplace */
1566          0,                     /* src_mask */
1567          0xffff,                /* dst_mask */
1568          FALSE),                /* pcrel_offset */
1569
1570   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1571   HOWTO (R_PPC64_TPREL16_HI,
1572          16,                    /* rightshift */
1573          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1574          16,                    /* bitsize */
1575          FALSE,                 /* pc_relative */
1576          0,                     /* bitpos */
1577          complain_overflow_signed, /* complain_on_overflow */
1578          ppc64_elf_unhandled_reloc, /* special_function */
1579          "R_PPC64_TPREL16_HI",  /* name */
1580          FALSE,                 /* partial_inplace */
1581          0,                     /* src_mask */
1582          0xffff,                /* dst_mask */
1583          FALSE),                /* pcrel_offset */
1584
1585   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1586   HOWTO (R_PPC64_TPREL16_HA,
1587          16,                    /* rightshift */
1588          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1589          16,                    /* bitsize */
1590          FALSE,                 /* pc_relative */
1591          0,                     /* bitpos */
1592          complain_overflow_signed, /* complain_on_overflow */
1593          ppc64_elf_unhandled_reloc, /* special_function */
1594          "R_PPC64_TPREL16_HA",  /* name */
1595          FALSE,                 /* partial_inplace */
1596          0,                     /* src_mask */
1597          0xffff,                /* dst_mask */
1598          FALSE),                /* pcrel_offset */
1599
1600   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1601   HOWTO (R_PPC64_TPREL16_HIGHER,
1602          32,                    /* rightshift */
1603          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1604          16,                    /* bitsize */
1605          FALSE,                 /* pc_relative */
1606          0,                     /* bitpos */
1607          complain_overflow_dont, /* complain_on_overflow */
1608          ppc64_elf_unhandled_reloc, /* special_function */
1609          "R_PPC64_TPREL16_HIGHER",      /* name */
1610          FALSE,                 /* partial_inplace */
1611          0,                     /* src_mask */
1612          0xffff,                /* dst_mask */
1613          FALSE),                /* pcrel_offset */
1614
1615   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1616   HOWTO (R_PPC64_TPREL16_HIGHERA,
1617          32,                    /* rightshift */
1618          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1619          16,                    /* bitsize */
1620          FALSE,                 /* pc_relative */
1621          0,                     /* bitpos */
1622          complain_overflow_dont, /* complain_on_overflow */
1623          ppc64_elf_unhandled_reloc, /* special_function */
1624          "R_PPC64_TPREL16_HIGHERA", /* name */
1625          FALSE,                 /* partial_inplace */
1626          0,                     /* src_mask */
1627          0xffff,                /* dst_mask */
1628          FALSE),                /* pcrel_offset */
1629
1630   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1631   HOWTO (R_PPC64_TPREL16_HIGHEST,
1632          48,                    /* rightshift */
1633          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1634          16,                    /* bitsize */
1635          FALSE,                 /* pc_relative */
1636          0,                     /* bitpos */
1637          complain_overflow_dont, /* complain_on_overflow */
1638          ppc64_elf_unhandled_reloc, /* special_function */
1639          "R_PPC64_TPREL16_HIGHEST", /* name */
1640          FALSE,                 /* partial_inplace */
1641          0,                     /* src_mask */
1642          0xffff,                /* dst_mask */
1643          FALSE),                /* pcrel_offset */
1644
1645   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1646   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1647          48,                    /* rightshift */
1648          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1649          16,                    /* bitsize */
1650          FALSE,                 /* pc_relative */
1651          0,                     /* bitpos */
1652          complain_overflow_dont, /* complain_on_overflow */
1653          ppc64_elf_unhandled_reloc, /* special_function */
1654          "R_PPC64_TPREL16_HIGHESTA", /* name */
1655          FALSE,                 /* partial_inplace */
1656          0,                     /* src_mask */
1657          0xffff,                /* dst_mask */
1658          FALSE),                /* pcrel_offset */
1659
1660   /* Like TPREL16, but for insns with a DS field.  */
1661   HOWTO (R_PPC64_TPREL16_DS,
1662          0,                     /* rightshift */
1663          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1664          16,                    /* bitsize */
1665          FALSE,                 /* pc_relative */
1666          0,                     /* bitpos */
1667          complain_overflow_signed, /* complain_on_overflow */
1668          ppc64_elf_unhandled_reloc, /* special_function */
1669          "R_PPC64_TPREL16_DS",  /* name */
1670          FALSE,                 /* partial_inplace */
1671          0,                     /* src_mask */
1672          0xfffc,                /* dst_mask */
1673          FALSE),                /* pcrel_offset */
1674
1675   /* Like TPREL16_DS, but no overflow.  */
1676   HOWTO (R_PPC64_TPREL16_LO_DS,
1677          0,                     /* rightshift */
1678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1679          16,                    /* bitsize */
1680          FALSE,                 /* pc_relative */
1681          0,                     /* bitpos */
1682          complain_overflow_dont, /* complain_on_overflow */
1683          ppc64_elf_unhandled_reloc, /* special_function */
1684          "R_PPC64_TPREL16_LO_DS", /* name */
1685          FALSE,                 /* partial_inplace */
1686          0,                     /* src_mask */
1687          0xfffc,                /* dst_mask */
1688          FALSE),                /* pcrel_offset */
1689
1690   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1691      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1692      to the first entry relative to the TOC base (r2).  */
1693   HOWTO (R_PPC64_GOT_TLSGD16,
1694          0,                     /* rightshift */
1695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1696          16,                    /* bitsize */
1697          FALSE,                 /* pc_relative */
1698          0,                     /* bitpos */
1699          complain_overflow_signed, /* complain_on_overflow */
1700          ppc64_elf_unhandled_reloc, /* special_function */
1701          "R_PPC64_GOT_TLSGD16", /* name */
1702          FALSE,                 /* partial_inplace */
1703          0,                     /* src_mask */
1704          0xffff,                /* dst_mask */
1705          FALSE),                /* pcrel_offset */
1706
1707   /* Like GOT_TLSGD16, but no overflow.  */
1708   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1709          0,                     /* rightshift */
1710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1711          16,                    /* bitsize */
1712          FALSE,                 /* pc_relative */
1713          0,                     /* bitpos */
1714          complain_overflow_dont, /* complain_on_overflow */
1715          ppc64_elf_unhandled_reloc, /* special_function */
1716          "R_PPC64_GOT_TLSGD16_LO", /* name */
1717          FALSE,                 /* partial_inplace */
1718          0,                     /* src_mask */
1719          0xffff,                /* dst_mask */
1720          FALSE),                /* pcrel_offset */
1721
1722   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1723   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1724          16,                    /* rightshift */
1725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1726          16,                    /* bitsize */
1727          FALSE,                 /* pc_relative */
1728          0,                     /* bitpos */
1729          complain_overflow_signed, /* complain_on_overflow */
1730          ppc64_elf_unhandled_reloc, /* special_function */
1731          "R_PPC64_GOT_TLSGD16_HI", /* name */
1732          FALSE,                 /* partial_inplace */
1733          0,                     /* src_mask */
1734          0xffff,                /* dst_mask */
1735          FALSE),                /* pcrel_offset */
1736
1737   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1738   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1739          16,                    /* rightshift */
1740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1741          16,                    /* bitsize */
1742          FALSE,                 /* pc_relative */
1743          0,                     /* bitpos */
1744          complain_overflow_signed, /* complain_on_overflow */
1745          ppc64_elf_unhandled_reloc, /* special_function */
1746          "R_PPC64_GOT_TLSGD16_HA", /* name */
1747          FALSE,                 /* partial_inplace */
1748          0,                     /* src_mask */
1749          0xffff,                /* dst_mask */
1750          FALSE),                /* pcrel_offset */
1751
1752   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1753      with values (sym+add)@dtpmod and zero, and computes the offset to the
1754      first entry relative to the TOC base (r2).  */
1755   HOWTO (R_PPC64_GOT_TLSLD16,
1756          0,                     /* rightshift */
1757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1758          16,                    /* bitsize */
1759          FALSE,                 /* pc_relative */
1760          0,                     /* bitpos */
1761          complain_overflow_signed, /* complain_on_overflow */
1762          ppc64_elf_unhandled_reloc, /* special_function */
1763          "R_PPC64_GOT_TLSLD16", /* name */
1764          FALSE,                 /* partial_inplace */
1765          0,                     /* src_mask */
1766          0xffff,                /* dst_mask */
1767          FALSE),                /* pcrel_offset */
1768
1769   /* Like GOT_TLSLD16, but no overflow.  */
1770   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1771          0,                     /* rightshift */
1772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1773          16,                    /* bitsize */
1774          FALSE,                 /* pc_relative */
1775          0,                     /* bitpos */
1776          complain_overflow_dont, /* complain_on_overflow */
1777          ppc64_elf_unhandled_reloc, /* special_function */
1778          "R_PPC64_GOT_TLSLD16_LO", /* name */
1779          FALSE,                 /* partial_inplace */
1780          0,                     /* src_mask */
1781          0xffff,                /* dst_mask */
1782          FALSE),                /* pcrel_offset */
1783
1784   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1785   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1786          16,                    /* rightshift */
1787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1788          16,                    /* bitsize */
1789          FALSE,                 /* pc_relative */
1790          0,                     /* bitpos */
1791          complain_overflow_signed, /* complain_on_overflow */
1792          ppc64_elf_unhandled_reloc, /* special_function */
1793          "R_PPC64_GOT_TLSLD16_HI", /* name */
1794          FALSE,                 /* partial_inplace */
1795          0,                     /* src_mask */
1796          0xffff,                /* dst_mask */
1797          FALSE),                /* pcrel_offset */
1798
1799   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1800   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1801          16,                    /* rightshift */
1802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1803          16,                    /* bitsize */
1804          FALSE,                 /* pc_relative */
1805          0,                     /* bitpos */
1806          complain_overflow_signed, /* complain_on_overflow */
1807          ppc64_elf_unhandled_reloc, /* special_function */
1808          "R_PPC64_GOT_TLSLD16_HA", /* name */
1809          FALSE,                 /* partial_inplace */
1810          0,                     /* src_mask */
1811          0xffff,                /* dst_mask */
1812          FALSE),                /* pcrel_offset */
1813
1814   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1815      the offset to the entry relative to the TOC base (r2).  */
1816   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1817          0,                     /* rightshift */
1818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1819          16,                    /* bitsize */
1820          FALSE,                 /* pc_relative */
1821          0,                     /* bitpos */
1822          complain_overflow_signed, /* complain_on_overflow */
1823          ppc64_elf_unhandled_reloc, /* special_function */
1824          "R_PPC64_GOT_DTPREL16_DS", /* name */
1825          FALSE,                 /* partial_inplace */
1826          0,                     /* src_mask */
1827          0xfffc,                /* dst_mask */
1828          FALSE),                /* pcrel_offset */
1829
1830   /* Like GOT_DTPREL16_DS, but no overflow.  */
1831   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1832          0,                     /* rightshift */
1833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1834          16,                    /* bitsize */
1835          FALSE,                 /* pc_relative */
1836          0,                     /* bitpos */
1837          complain_overflow_dont, /* complain_on_overflow */
1838          ppc64_elf_unhandled_reloc, /* special_function */
1839          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1840          FALSE,                 /* partial_inplace */
1841          0,                     /* src_mask */
1842          0xfffc,                /* dst_mask */
1843          FALSE),                /* pcrel_offset */
1844
1845   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1846   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1847          16,                    /* rightshift */
1848          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1849          16,                    /* bitsize */
1850          FALSE,                 /* pc_relative */
1851          0,                     /* bitpos */
1852          complain_overflow_signed, /* complain_on_overflow */
1853          ppc64_elf_unhandled_reloc, /* special_function */
1854          "R_PPC64_GOT_DTPREL16_HI", /* name */
1855          FALSE,                 /* partial_inplace */
1856          0,                     /* src_mask */
1857          0xffff,                /* dst_mask */
1858          FALSE),                /* pcrel_offset */
1859
1860   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1861   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1862          16,                    /* rightshift */
1863          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1864          16,                    /* bitsize */
1865          FALSE,                 /* pc_relative */
1866          0,                     /* bitpos */
1867          complain_overflow_signed, /* complain_on_overflow */
1868          ppc64_elf_unhandled_reloc, /* special_function */
1869          "R_PPC64_GOT_DTPREL16_HA", /* name */
1870          FALSE,                 /* partial_inplace */
1871          0,                     /* src_mask */
1872          0xffff,                /* dst_mask */
1873          FALSE),                /* pcrel_offset */
1874
1875   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1876      offset to the entry relative to the TOC base (r2).  */
1877   HOWTO (R_PPC64_GOT_TPREL16_DS,
1878          0,                     /* rightshift */
1879          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1880          16,                    /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_signed, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_GOT_TPREL16_DS", /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0xfffc,                /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   /* Like GOT_TPREL16_DS, but no overflow.  */
1892   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1893          0,                     /* rightshift */
1894          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1895          16,                    /* bitsize */
1896          FALSE,                 /* pc_relative */
1897          0,                     /* bitpos */
1898          complain_overflow_dont, /* complain_on_overflow */
1899          ppc64_elf_unhandled_reloc, /* special_function */
1900          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1901          FALSE,                 /* partial_inplace */
1902          0,                     /* src_mask */
1903          0xfffc,                /* dst_mask */
1904          FALSE),                /* pcrel_offset */
1905
1906   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1907   HOWTO (R_PPC64_GOT_TPREL16_HI,
1908          16,                    /* rightshift */
1909          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1910          16,                    /* bitsize */
1911          FALSE,                 /* pc_relative */
1912          0,                     /* bitpos */
1913          complain_overflow_signed, /* complain_on_overflow */
1914          ppc64_elf_unhandled_reloc, /* special_function */
1915          "R_PPC64_GOT_TPREL16_HI", /* name */
1916          FALSE,                 /* partial_inplace */
1917          0,                     /* src_mask */
1918          0xffff,                /* dst_mask */
1919          FALSE),                /* pcrel_offset */
1920
1921   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1922   HOWTO (R_PPC64_GOT_TPREL16_HA,
1923          16,                    /* rightshift */
1924          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1925          16,                    /* bitsize */
1926          FALSE,                 /* pc_relative */
1927          0,                     /* bitpos */
1928          complain_overflow_signed, /* complain_on_overflow */
1929          ppc64_elf_unhandled_reloc, /* special_function */
1930          "R_PPC64_GOT_TPREL16_HA", /* name */
1931          FALSE,                 /* partial_inplace */
1932          0,                     /* src_mask */
1933          0xffff,                /* dst_mask */
1934          FALSE),                /* pcrel_offset */
1935
1936   HOWTO (R_PPC64_JMP_IREL,      /* type */
1937          0,                     /* rightshift */
1938          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1939          0,                     /* bitsize */
1940          FALSE,                 /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          ppc64_elf_unhandled_reloc, /* special_function */
1944          "R_PPC64_JMP_IREL",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0,                     /* dst_mask */
1948          FALSE),                /* pcrel_offset */
1949
1950   HOWTO (R_PPC64_IRELATIVE,     /* type */
1951          0,                     /* rightshift */
1952          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1953          64,                    /* bitsize */
1954          FALSE,                 /* pc_relative */
1955          0,                     /* bitpos */
1956          complain_overflow_dont, /* complain_on_overflow */
1957          bfd_elf_generic_reloc, /* special_function */
1958          "R_PPC64_IRELATIVE",   /* name */
1959          FALSE,                 /* partial_inplace */
1960          0,                     /* src_mask */
1961          ONES (64),             /* dst_mask */
1962          FALSE),                /* pcrel_offset */
1963
1964   /* A 16 bit relative relocation.  */
1965   HOWTO (R_PPC64_REL16,         /* type */
1966          0,                     /* rightshift */
1967          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1968          16,                    /* bitsize */
1969          TRUE,                  /* pc_relative */
1970          0,                     /* bitpos */
1971          complain_overflow_signed, /* complain_on_overflow */
1972          bfd_elf_generic_reloc, /* special_function */
1973          "R_PPC64_REL16",       /* name */
1974          FALSE,                 /* partial_inplace */
1975          0,                     /* src_mask */
1976          0xffff,                /* dst_mask */
1977          TRUE),                 /* pcrel_offset */
1978
1979   /* A 16 bit relative relocation without overflow.  */
1980   HOWTO (R_PPC64_REL16_LO,      /* type */
1981          0,                     /* rightshift */
1982          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1983          16,                    /* bitsize */
1984          TRUE,                  /* pc_relative */
1985          0,                     /* bitpos */
1986          complain_overflow_dont,/* complain_on_overflow */
1987          bfd_elf_generic_reloc, /* special_function */
1988          "R_PPC64_REL16_LO",    /* name */
1989          FALSE,                 /* partial_inplace */
1990          0,                     /* src_mask */
1991          0xffff,                /* dst_mask */
1992          TRUE),                 /* pcrel_offset */
1993
1994   /* The high order 16 bits of a relative address.  */
1995   HOWTO (R_PPC64_REL16_HI,      /* type */
1996          16,                    /* rightshift */
1997          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1998          16,                    /* bitsize */
1999          TRUE,                  /* pc_relative */
2000          0,                     /* bitpos */
2001          complain_overflow_signed, /* complain_on_overflow */
2002          bfd_elf_generic_reloc, /* special_function */
2003          "R_PPC64_REL16_HI",    /* name */
2004          FALSE,                 /* partial_inplace */
2005          0,                     /* src_mask */
2006          0xffff,                /* dst_mask */
2007          TRUE),                 /* pcrel_offset */
2008
2009   /* The high order 16 bits of a relative address, plus 1 if the contents of
2010      the low 16 bits, treated as a signed number, is negative.  */
2011   HOWTO (R_PPC64_REL16_HA,      /* type */
2012          16,                    /* rightshift */
2013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2014          16,                    /* bitsize */
2015          TRUE,                  /* pc_relative */
2016          0,                     /* bitpos */
2017          complain_overflow_signed, /* complain_on_overflow */
2018          ppc64_elf_ha_reloc,    /* special_function */
2019          "R_PPC64_REL16_HA",    /* name */
2020          FALSE,                 /* partial_inplace */
2021          0,                     /* src_mask */
2022          0xffff,                /* dst_mask */
2023          TRUE),                 /* pcrel_offset */
2024
2025   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2026   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2027          16,                    /* rightshift */
2028          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2029          16,                    /* bitsize */
2030          FALSE,                 /* pc_relative */
2031          0,                     /* bitpos */
2032          complain_overflow_dont, /* complain_on_overflow */
2033          bfd_elf_generic_reloc, /* special_function */
2034          "R_PPC64_ADDR16_HIGH", /* name */
2035          FALSE,                 /* partial_inplace */
2036          0,                     /* src_mask */
2037          0xffff,                /* dst_mask */
2038          FALSE),                /* pcrel_offset */
2039
2040   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2041   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2042          16,                    /* rightshift */
2043          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2044          16,                    /* bitsize */
2045          FALSE,                 /* pc_relative */
2046          0,                     /* bitpos */
2047          complain_overflow_dont, /* complain_on_overflow */
2048          ppc64_elf_ha_reloc,    /* special_function */
2049          "R_PPC64_ADDR16_HIGHA",        /* name */
2050          FALSE,                 /* partial_inplace */
2051          0,                     /* src_mask */
2052          0xffff,                /* dst_mask */
2053          FALSE),                /* pcrel_offset */
2054
2055   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2056   HOWTO (R_PPC64_DTPREL16_HIGH,
2057          16,                    /* rightshift */
2058          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2059          16,                    /* bitsize */
2060          FALSE,                 /* pc_relative */
2061          0,                     /* bitpos */
2062          complain_overflow_dont, /* complain_on_overflow */
2063          ppc64_elf_unhandled_reloc, /* special_function */
2064          "R_PPC64_DTPREL16_HIGH", /* name */
2065          FALSE,                 /* partial_inplace */
2066          0,                     /* src_mask */
2067          0xffff,                /* dst_mask */
2068          FALSE),                /* pcrel_offset */
2069
2070   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2071   HOWTO (R_PPC64_DTPREL16_HIGHA,
2072          16,                    /* rightshift */
2073          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2074          16,                    /* bitsize */
2075          FALSE,                 /* pc_relative */
2076          0,                     /* bitpos */
2077          complain_overflow_dont, /* complain_on_overflow */
2078          ppc64_elf_unhandled_reloc, /* special_function */
2079          "R_PPC64_DTPREL16_HIGHA", /* name */
2080          FALSE,                 /* partial_inplace */
2081          0,                     /* src_mask */
2082          0xffff,                /* dst_mask */
2083          FALSE),                /* pcrel_offset */
2084
2085   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2086   HOWTO (R_PPC64_TPREL16_HIGH,
2087          16,                    /* rightshift */
2088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2089          16,                    /* bitsize */
2090          FALSE,                 /* pc_relative */
2091          0,                     /* bitpos */
2092          complain_overflow_dont, /* complain_on_overflow */
2093          ppc64_elf_unhandled_reloc, /* special_function */
2094          "R_PPC64_TPREL16_HIGH",        /* name */
2095          FALSE,                 /* partial_inplace */
2096          0,                     /* src_mask */
2097          0xffff,                /* dst_mask */
2098          FALSE),                /* pcrel_offset */
2099
2100   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2101   HOWTO (R_PPC64_TPREL16_HIGHA,
2102          16,                    /* rightshift */
2103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2104          16,                    /* bitsize */
2105          FALSE,                 /* pc_relative */
2106          0,                     /* bitpos */
2107          complain_overflow_dont, /* complain_on_overflow */
2108          ppc64_elf_unhandled_reloc, /* special_function */
2109          "R_PPC64_TPREL16_HIGHA",       /* name */
2110          FALSE,                 /* partial_inplace */
2111          0,                     /* src_mask */
2112          0xffff,                /* dst_mask */
2113          FALSE),                /* pcrel_offset */
2114
2115   /* Like ADDR64, but use local entry point of function.  */
2116   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2117          0,                     /* rightshift */
2118          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2119          64,                    /* bitsize */
2120          FALSE,                 /* pc_relative */
2121          0,                     /* bitpos */
2122          complain_overflow_dont, /* complain_on_overflow */
2123          bfd_elf_generic_reloc, /* special_function */
2124          "R_PPC64_ADDR64_LOCAL", /* name */
2125          FALSE,                 /* partial_inplace */
2126          0,                     /* src_mask */
2127          ONES (64),             /* dst_mask */
2128          FALSE),                /* pcrel_offset */
2129
2130   /* GNU extension to record C++ vtable hierarchy.  */
2131   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2132          0,                     /* rightshift */
2133          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2134          0,                     /* bitsize */
2135          FALSE,                 /* pc_relative */
2136          0,                     /* bitpos */
2137          complain_overflow_dont, /* complain_on_overflow */
2138          NULL,                  /* special_function */
2139          "R_PPC64_GNU_VTINHERIT", /* name */
2140          FALSE,                 /* partial_inplace */
2141          0,                     /* src_mask */
2142          0,                     /* dst_mask */
2143          FALSE),                /* pcrel_offset */
2144
2145   /* GNU extension to record C++ vtable member usage.  */
2146   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2147          0,                     /* rightshift */
2148          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2149          0,                     /* bitsize */
2150          FALSE,                 /* pc_relative */
2151          0,                     /* bitpos */
2152          complain_overflow_dont, /* complain_on_overflow */
2153          NULL,                  /* special_function */
2154          "R_PPC64_GNU_VTENTRY", /* name */
2155          FALSE,                 /* partial_inplace */
2156          0,                     /* src_mask */
2157          0,                     /* dst_mask */
2158          FALSE),                /* pcrel_offset */
2159 };
2160
2161 \f
2162 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2163    be done.  */
2164
2165 static void
2166 ppc_howto_init (void)
2167 {
2168   unsigned int i, type;
2169
2170   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2171     {
2172       type = ppc64_elf_howto_raw[i].type;
2173       BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2174       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2175     }
2176 }
2177
2178 static reloc_howto_type *
2179 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2180                              bfd_reloc_code_real_type code)
2181 {
2182   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2183
2184   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2185     /* Initialize howto table if needed.  */
2186     ppc_howto_init ();
2187
2188   switch (code)
2189     {
2190     default:
2191       return NULL;
2192
2193     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2194       break;
2195     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2196       break;
2197     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2198       break;
2199     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2200       break;
2201     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2202       break;
2203     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2204       break;
2205     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2206       break;
2207     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2208       break;
2209     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2210       break;
2211     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2212       break;
2213     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2214       break;
2215     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2216       break;
2217     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2218       break;
2219     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2220       break;
2221     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2222       break;
2223     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2224       break;
2225     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2226       break;
2227     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2228       break;
2229     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2230       break;
2231     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2232       break;
2233     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2234       break;
2235     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2236       break;
2237     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2238       break;
2239     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2240       break;
2241     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2242       break;
2243     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2244       break;
2245     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2246       break;
2247     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2248       break;
2249     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2250       break;
2251     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2252       break;
2253     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2254       break;
2255     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2256       break;
2257     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2258       break;
2259     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2260       break;
2261     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2262       break;
2263     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2264       break;
2265     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2266       break;
2267     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2268       break;
2269     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2270       break;
2271     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2272       break;
2273     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2274       break;
2275     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2276       break;
2277     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2278       break;
2279     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2280       break;
2281     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2282       break;
2283     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2284       break;
2285     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2286       break;
2287     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2288       break;
2289     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2290       break;
2291     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2292       break;
2293     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2294       break;
2295     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2296       break;
2297     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2298       break;
2299     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2300       break;
2301     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2302       break;
2303     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2304       break;
2305     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2306       break;
2307     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2308       break;
2309     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2310       break;
2311     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2312       break;
2313     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2314       break;
2315     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2316       break;
2317     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2318       break;
2319     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2320       break;
2321     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2322       break;
2323     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2324       break;
2325     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2326       break;
2327     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2328       break;
2329     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2330       break;
2331     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2332       break;
2333     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2334       break;
2335     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2336       break;
2337     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2338       break;
2339     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2340       break;
2341     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2342       break;
2343     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2344       break;
2345     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2346       break;
2347     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2348       break;
2349     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2350       break;
2351     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2352       break;
2353     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2354       break;
2355     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2356       break;
2357     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2358       break;
2359     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2360       break;
2361     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2362       break;
2363     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2364       break;
2365     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2366       break;
2367     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2368       break;
2369     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2370       break;
2371     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2372       break;
2373     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2374       break;
2375     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2376       break;
2377     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2378       break;
2379     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2380       break;
2381     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2382       break;
2383     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2384       break;
2385     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2386       break;
2387     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2388       break;
2389     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2390       break;
2391     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2392       break;
2393     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2394       break;
2395     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2396       break;
2397     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2398       break;
2399     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2400       break;
2401     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2402       break;
2403     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2404       break;
2405     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2406       break;
2407     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2408       break;
2409     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2410       break;
2411     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2412       break;
2413     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2414       break;
2415     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2416       break;
2417     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2418       break;
2419     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2420       break;
2421     }
2422
2423   return ppc64_elf_howto_table[r];
2424 };
2425
2426 static reloc_howto_type *
2427 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2428                              const char *r_name)
2429 {
2430   unsigned int i;
2431
2432   for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2433     if (ppc64_elf_howto_raw[i].name != NULL
2434         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2435       return &ppc64_elf_howto_raw[i];
2436
2437   return NULL;
2438 }
2439
2440 /* Set the howto pointer for a PowerPC ELF reloc.  */
2441
2442 static void
2443 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2444                          Elf_Internal_Rela *dst)
2445 {
2446   unsigned int type;
2447
2448   /* Initialize howto table if needed.  */
2449   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2450     ppc_howto_init ();
2451
2452   type = ELF64_R_TYPE (dst->r_info);
2453   if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2454     {
2455       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2456                              abfd, (int) type);
2457       type = R_PPC64_NONE;
2458     }
2459   cache_ptr->howto = ppc64_elf_howto_table[type];
2460 }
2461
2462 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2463
2464 static bfd_reloc_status_type
2465 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2466                     void *data, asection *input_section,
2467                     bfd *output_bfd, char **error_message)
2468 {
2469   /* If this is a relocatable link (output_bfd test tells us), just
2470      call the generic function.  Any adjustment will be done at final
2471      link time.  */
2472   if (output_bfd != NULL)
2473     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2474                                   input_section, output_bfd, error_message);
2475
2476   /* Adjust the addend for sign extension of the low 16 bits.
2477      We won't actually be using the low 16 bits, so trashing them
2478      doesn't matter.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                         void *data, asection *input_section,
2486                         bfd *output_bfd, char **error_message)
2487 {
2488   if (output_bfd != NULL)
2489     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2490                                   input_section, output_bfd, error_message);
2491
2492   if (strcmp (symbol->section->name, ".opd") == 0
2493       && (symbol->section->owner->flags & DYNAMIC) == 0)
2494     {
2495       bfd_vma dest = opd_entry_value (symbol->section,
2496                                       symbol->value + reloc_entry->addend,
2497                                       NULL, NULL, FALSE);
2498       if (dest != (bfd_vma) -1)
2499         reloc_entry->addend = dest - (symbol->value
2500                                       + symbol->section->output_section->vma
2501                                       + symbol->section->output_offset);
2502     }
2503   else
2504     {
2505       elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2506
2507       if (symbol->section->owner != abfd
2508           && abiversion (symbol->section->owner) >= 2)
2509         {
2510           unsigned int i;
2511
2512           for (i = 0; i < symbol->section->owner->symcount; ++i)
2513             {
2514               asymbol *symdef = symbol->section->owner->outsymbols[i];
2515
2516               if (strcmp (symdef->name, symbol->name) == 0)
2517                 {
2518                   elfsym = (elf_symbol_type *) symdef;
2519                   break;
2520                 }
2521             }
2522         }
2523       reloc_entry->addend
2524         += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2525     }
2526   return bfd_reloc_continue;
2527 }
2528
2529 static bfd_reloc_status_type
2530 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2531                          void *data, asection *input_section,
2532                          bfd *output_bfd, char **error_message)
2533 {
2534   long insn;
2535   enum elf_ppc64_reloc_type r_type;
2536   bfd_size_type octets;
2537   /* Assume 'at' branch hints.  */
2538   bfd_boolean is_isa_v2 = TRUE;
2539
2540   /* If this is a relocatable link (output_bfd test tells us), just
2541      call the generic function.  Any adjustment will be done at final
2542      link time.  */
2543   if (output_bfd != NULL)
2544     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2545                                   input_section, output_bfd, error_message);
2546
2547   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2548   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2549   insn &= ~(0x01 << 21);
2550   r_type = reloc_entry->howto->type;
2551   if (r_type == R_PPC64_ADDR14_BRTAKEN
2552       || r_type == R_PPC64_REL14_BRTAKEN)
2553     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2554
2555   if (is_isa_v2)
2556     {
2557       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2558          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2559          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2560       if ((insn & (0x14 << 21)) == (0x04 << 21))
2561         insn |= 0x02 << 21;
2562       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2563         insn |= 0x08 << 21;
2564       else
2565         goto out;
2566     }
2567   else
2568     {
2569       bfd_vma target = 0;
2570       bfd_vma from;
2571
2572       if (!bfd_is_com_section (symbol->section))
2573         target = symbol->value;
2574       target += symbol->section->output_section->vma;
2575       target += symbol->section->output_offset;
2576       target += reloc_entry->addend;
2577
2578       from = (reloc_entry->address
2579               + input_section->output_offset
2580               + input_section->output_section->vma);
2581
2582       /* Invert 'y' bit if not the default.  */
2583       if ((bfd_signed_vma) (target - from) < 0)
2584         insn ^= 0x01 << 21;
2585     }
2586   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2587  out:
2588   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2589                                  input_section, output_bfd, error_message);
2590 }
2591
2592 static bfd_reloc_status_type
2593 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2594                          void *data, asection *input_section,
2595                          bfd *output_bfd, char **error_message)
2596 {
2597   /* If this is a relocatable link (output_bfd test tells us), just
2598      call the generic function.  Any adjustment will be done at final
2599      link time.  */
2600   if (output_bfd != NULL)
2601     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2602                                   input_section, output_bfd, error_message);
2603
2604   /* Subtract the symbol section base address.  */
2605   reloc_entry->addend -= symbol->section->output_section->vma;
2606   return bfd_reloc_continue;
2607 }
2608
2609 static bfd_reloc_status_type
2610 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2611                             void *data, asection *input_section,
2612                             bfd *output_bfd, char **error_message)
2613 {
2614   /* If this is a relocatable link (output_bfd test tells us), just
2615      call the generic function.  Any adjustment will be done at final
2616      link time.  */
2617   if (output_bfd != NULL)
2618     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2619                                   input_section, output_bfd, error_message);
2620
2621   /* Subtract the symbol section base address.  */
2622   reloc_entry->addend -= symbol->section->output_section->vma;
2623
2624   /* Adjust the addend for sign extension of the low 16 bits.  */
2625   reloc_entry->addend += 0x8000;
2626   return bfd_reloc_continue;
2627 }
2628
2629 static bfd_reloc_status_type
2630 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2631                      void *data, asection *input_section,
2632                      bfd *output_bfd, char **error_message)
2633 {
2634   bfd_vma TOCstart;
2635
2636   /* If this is a relocatable link (output_bfd test tells us), just
2637      call the generic function.  Any adjustment will be done at final
2638      link time.  */
2639   if (output_bfd != NULL)
2640     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2641                                   input_section, output_bfd, error_message);
2642
2643   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644   if (TOCstart == 0)
2645     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2646
2647   /* Subtract the TOC base address.  */
2648   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2649   return bfd_reloc_continue;
2650 }
2651
2652 static bfd_reloc_status_type
2653 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654                         void *data, asection *input_section,
2655                         bfd *output_bfd, char **error_message)
2656 {
2657   bfd_vma TOCstart;
2658
2659   /* If this is a relocatable link (output_bfd test tells us), just
2660      call the generic function.  Any adjustment will be done at final
2661      link time.  */
2662   if (output_bfd != NULL)
2663     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2664                                   input_section, output_bfd, error_message);
2665
2666   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2667   if (TOCstart == 0)
2668     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2669
2670   /* Subtract the TOC base address.  */
2671   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2672
2673   /* Adjust the addend for sign extension of the low 16 bits.  */
2674   reloc_entry->addend += 0x8000;
2675   return bfd_reloc_continue;
2676 }
2677
2678 static bfd_reloc_status_type
2679 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2680                        void *data, asection *input_section,
2681                        bfd *output_bfd, char **error_message)
2682 {
2683   bfd_vma TOCstart;
2684   bfd_size_type octets;
2685
2686   /* If this is a relocatable link (output_bfd test tells us), just
2687      call the generic function.  Any adjustment will be done at final
2688      link time.  */
2689   if (output_bfd != NULL)
2690     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2691                                   input_section, output_bfd, error_message);
2692
2693   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2694   if (TOCstart == 0)
2695     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2696
2697   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2698   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2699   return bfd_reloc_ok;
2700 }
2701
2702 static bfd_reloc_status_type
2703 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2704                            void *data, asection *input_section,
2705                            bfd *output_bfd, char **error_message)
2706 {
2707   /* If this is a relocatable link (output_bfd test tells us), just
2708      call the generic function.  Any adjustment will be done at final
2709      link time.  */
2710   if (output_bfd != NULL)
2711     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2712                                   input_section, output_bfd, error_message);
2713
2714   if (error_message != NULL)
2715     {
2716       static char buf[60];
2717       sprintf (buf, "generic linker can't handle %s",
2718                reloc_entry->howto->name);
2719       *error_message = buf;
2720     }
2721   return bfd_reloc_dangerous;
2722 }
2723
2724 /* Track GOT entries needed for a given symbol.  We might need more
2725    than one got entry per symbol.  */
2726 struct got_entry
2727 {
2728   struct got_entry *next;
2729
2730   /* The symbol addend that we'll be placing in the GOT.  */
2731   bfd_vma addend;
2732
2733   /* Unlike other ELF targets, we use separate GOT entries for the same
2734      symbol referenced from different input files.  This is to support
2735      automatic multiple TOC/GOT sections, where the TOC base can vary
2736      from one input file to another.  After partitioning into TOC groups
2737      we merge entries within the group.
2738
2739      Point to the BFD owning this GOT entry.  */
2740   bfd *owner;
2741
2742   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2743      TLS_TPREL or TLS_DTPREL for tls entries.  */
2744   unsigned char tls_type;
2745
2746   /* Non-zero if got.ent points to real entry.  */
2747   unsigned char is_indirect;
2748
2749   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2750   union
2751     {
2752       bfd_signed_vma refcount;
2753       bfd_vma offset;
2754       struct got_entry *ent;
2755     } got;
2756 };
2757
2758 /* The same for PLT.  */
2759 struct plt_entry
2760 {
2761   struct plt_entry *next;
2762
2763   bfd_vma addend;
2764
2765   union
2766     {
2767       bfd_signed_vma refcount;
2768       bfd_vma offset;
2769     } plt;
2770 };
2771
2772 struct ppc64_elf_obj_tdata
2773 {
2774   struct elf_obj_tdata elf;
2775
2776   /* Shortcuts to dynamic linker sections.  */
2777   asection *got;
2778   asection *relgot;
2779
2780   /* Used during garbage collection.  We attach global symbols defined
2781      on removed .opd entries to this section so that the sym is removed.  */
2782   asection *deleted_section;
2783
2784   /* TLS local dynamic got entry handling.  Support for multiple GOT
2785      sections means we potentially need one of these for each input bfd.  */
2786   struct got_entry tlsld_got;
2787
2788   union {
2789     /* A copy of relocs before they are modified for --emit-relocs.  */
2790     Elf_Internal_Rela *relocs;
2791
2792     /* Section contents.  */
2793     bfd_byte *contents;
2794   } opd;
2795
2796   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2797      the reloc to be in the range -32768 to 32767.  */
2798   unsigned int has_small_toc_reloc : 1;
2799
2800   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2801      instruction not one we handle.  */
2802   unsigned int unexpected_toc_insn : 1;
2803 };
2804
2805 #define ppc64_elf_tdata(bfd) \
2806   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2807
2808 #define ppc64_tlsld_got(bfd) \
2809   (&ppc64_elf_tdata (bfd)->tlsld_got)
2810
2811 #define is_ppc64_elf(bfd) \
2812   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2813    && elf_object_id (bfd) == PPC64_ELF_DATA)
2814
2815 /* Override the generic function because we store some extras.  */
2816
2817 static bfd_boolean
2818 ppc64_elf_mkobject (bfd *abfd)
2819 {
2820   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2821                                   PPC64_ELF_DATA);
2822 }
2823
2824 /* Fix bad default arch selected for a 64 bit input bfd when the
2825    default is 32 bit.  */
2826
2827 static bfd_boolean
2828 ppc64_elf_object_p (bfd *abfd)
2829 {
2830   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2831     {
2832       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2833
2834       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2835         {
2836           /* Relies on arch after 32 bit default being 64 bit default.  */
2837           abfd->arch_info = abfd->arch_info->next;
2838           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2839         }
2840     }
2841   return TRUE;
2842 }
2843
2844 /* Support for core dump NOTE sections.  */
2845
2846 static bfd_boolean
2847 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2848 {
2849   size_t offset, size;
2850
2851   if (note->descsz != 504)
2852     return FALSE;
2853
2854   /* pr_cursig */
2855   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2856
2857   /* pr_pid */
2858   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2859
2860   /* pr_reg */
2861   offset = 112;
2862   size = 384;
2863
2864   /* Make a ".reg/999" section.  */
2865   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2866                                           size, note->descpos + offset);
2867 }
2868
2869 static bfd_boolean
2870 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2871 {
2872   if (note->descsz != 136)
2873     return FALSE;
2874
2875   elf_tdata (abfd)->core->pid
2876     = bfd_get_32 (abfd, note->descdata + 24);
2877   elf_tdata (abfd)->core->program
2878     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2879   elf_tdata (abfd)->core->command
2880     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2881
2882   return TRUE;
2883 }
2884
2885 static char *
2886 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2887                            ...)
2888 {
2889   switch (note_type)
2890     {
2891     default:
2892       return NULL;
2893
2894     case NT_PRPSINFO:
2895       {
2896         char data[136];
2897         va_list ap;
2898
2899         va_start (ap, note_type);
2900         memset (data, 0, sizeof (data));
2901         strncpy (data + 40, va_arg (ap, const char *), 16);
2902         strncpy (data + 56, va_arg (ap, const char *), 80);
2903         va_end (ap);
2904         return elfcore_write_note (abfd, buf, bufsiz,
2905                                    "CORE", note_type, data, sizeof (data));
2906       }
2907
2908     case NT_PRSTATUS:
2909       {
2910         char data[504];
2911         va_list ap;
2912         long pid;
2913         int cursig;
2914         const void *greg;
2915
2916         va_start (ap, note_type);
2917         memset (data, 0, 112);
2918         pid = va_arg (ap, long);
2919         bfd_put_32 (abfd, pid, data + 32);
2920         cursig = va_arg (ap, int);
2921         bfd_put_16 (abfd, cursig, data + 12);
2922         greg = va_arg (ap, const void *);
2923         memcpy (data + 112, greg, 384);
2924         memset (data + 496, 0, 8);
2925         va_end (ap);
2926         return elfcore_write_note (abfd, buf, bufsiz,
2927                                    "CORE", note_type, data, sizeof (data));
2928       }
2929     }
2930 }
2931
2932 /* Add extra PPC sections.  */
2933
2934 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2935 {
2936   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2937   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2938   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2939   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2940   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2941   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2942   { NULL,                     0,  0, 0,            0 }
2943 };
2944
2945 enum _ppc64_sec_type {
2946   sec_normal = 0,
2947   sec_opd = 1,
2948   sec_toc = 2
2949 };
2950
2951 struct _ppc64_elf_section_data
2952 {
2953   struct bfd_elf_section_data elf;
2954
2955   union
2956   {
2957     /* An array with one entry for each opd function descriptor,
2958        and some spares since opd entries may be either 16 or 24 bytes.  */
2959 #define OPD_NDX(OFF) ((OFF) >> 4)
2960     struct _opd_sec_data
2961     {
2962       /* Points to the function code section for local opd entries.  */
2963       asection **func_sec;
2964
2965       /* After editing .opd, adjust references to opd local syms.  */
2966       long *adjust;
2967     } opd;
2968
2969     /* An array for toc sections, indexed by offset/8.  */
2970     struct _toc_sec_data
2971     {
2972       /* Specifies the relocation symbol index used at a given toc offset.  */
2973       unsigned *symndx;
2974
2975       /* And the relocation addend.  */
2976       bfd_vma *add;
2977     } toc;
2978   } u;
2979
2980   enum _ppc64_sec_type sec_type:2;
2981
2982   /* Flag set when small branches are detected.  Used to
2983      select suitable defaults for the stub group size.  */
2984   unsigned int has_14bit_branch:1;
2985 };
2986
2987 #define ppc64_elf_section_data(sec) \
2988   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2989
2990 static bfd_boolean
2991 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2992 {
2993   if (!sec->used_by_bfd)
2994     {
2995       struct _ppc64_elf_section_data *sdata;
2996       bfd_size_type amt = sizeof (*sdata);
2997
2998       sdata = bfd_zalloc (abfd, amt);
2999       if (sdata == NULL)
3000         return FALSE;
3001       sec->used_by_bfd = sdata;
3002     }
3003
3004   return _bfd_elf_new_section_hook (abfd, sec);
3005 }
3006
3007 static struct _opd_sec_data *
3008 get_opd_info (asection * sec)
3009 {
3010   if (sec != NULL
3011       && ppc64_elf_section_data (sec) != NULL
3012       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3013     return &ppc64_elf_section_data (sec)->u.opd;
3014   return NULL;
3015 }
3016 \f
3017 /* Parameters for the qsort hook.  */
3018 static bfd_boolean synthetic_relocatable;
3019
3020 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3021
3022 static int
3023 compare_symbols (const void *ap, const void *bp)
3024 {
3025   const asymbol *a = * (const asymbol **) ap;
3026   const asymbol *b = * (const asymbol **) bp;
3027
3028   /* Section symbols first.  */
3029   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3030     return -1;
3031   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3032     return 1;
3033
3034   /* then .opd symbols.  */
3035   if (strcmp (a->section->name, ".opd") == 0
3036       && strcmp (b->section->name, ".opd") != 0)
3037     return -1;
3038   if (strcmp (a->section->name, ".opd") != 0
3039       && strcmp (b->section->name, ".opd") == 0)
3040     return 1;
3041
3042   /* then other code symbols.  */
3043   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044       == (SEC_CODE | SEC_ALLOC)
3045       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3046          != (SEC_CODE | SEC_ALLOC))
3047     return -1;
3048
3049   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050       != (SEC_CODE | SEC_ALLOC)
3051       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3052          == (SEC_CODE | SEC_ALLOC))
3053     return 1;
3054
3055   if (synthetic_relocatable)
3056     {
3057       if (a->section->id < b->section->id)
3058         return -1;
3059
3060       if (a->section->id > b->section->id)
3061         return 1;
3062     }
3063
3064   if (a->value + a->section->vma < b->value + b->section->vma)
3065     return -1;
3066
3067   if (a->value + a->section->vma > b->value + b->section->vma)
3068     return 1;
3069
3070   /* For syms with the same value, prefer strong dynamic global function
3071      syms over other syms.  */
3072   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3073     return -1;
3074
3075   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3076     return 1;
3077
3078   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3079     return -1;
3080
3081   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3082     return 1;
3083
3084   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3085     return -1;
3086
3087   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3088     return 1;
3089
3090   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3091     return -1;
3092
3093   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3094     return 1;
3095
3096   return 0;
3097 }
3098
3099 /* Search SYMS for a symbol of the given VALUE.  */
3100
3101 static asymbol *
3102 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3103 {
3104   long mid;
3105
3106   if (id == (unsigned) -1)
3107     {
3108       while (lo < hi)
3109         {
3110           mid = (lo + hi) >> 1;
3111           if (syms[mid]->value + syms[mid]->section->vma < value)
3112             lo = mid + 1;
3113           else if (syms[mid]->value + syms[mid]->section->vma > value)
3114             hi = mid;
3115           else
3116             return syms[mid];
3117         }
3118     }
3119   else
3120     {
3121       while (lo < hi)
3122         {
3123           mid = (lo + hi) >> 1;
3124           if (syms[mid]->section->id < id)
3125             lo = mid + 1;
3126           else if (syms[mid]->section->id > id)
3127             hi = mid;
3128           else if (syms[mid]->value < value)
3129             lo = mid + 1;
3130           else if (syms[mid]->value > value)
3131             hi = mid;
3132           else
3133             return syms[mid];
3134         }
3135     }
3136   return NULL;
3137 }
3138
3139 static bfd_boolean
3140 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3141 {
3142   bfd_vma vma = *(bfd_vma *) ptr;
3143   return ((section->flags & SEC_ALLOC) != 0
3144           && section->vma <= vma
3145           && vma < section->vma + section->size);
3146 }
3147
3148 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3149    entry syms.  Also generate @plt symbols for the glink branch table.
3150    Returns count of synthetic symbols in RET or -1 on error.  */
3151
3152 static long
3153 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3154                                 long static_count, asymbol **static_syms,
3155                                 long dyn_count, asymbol **dyn_syms,
3156                                 asymbol **ret)
3157 {
3158   asymbol *s;
3159   long i;
3160   long count;
3161   char *names;
3162   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3163   asection *opd = NULL;
3164   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3165   asymbol **syms;
3166   int abi = abiversion (abfd);
3167
3168   *ret = NULL;
3169
3170   if (abi < 2)
3171     {
3172       opd = bfd_get_section_by_name (abfd, ".opd");
3173       if (opd == NULL && abi == 1)
3174         return 0;
3175     }
3176
3177   symcount = static_count;
3178   if (!relocatable)
3179     symcount += dyn_count;
3180   if (symcount == 0)
3181     return 0;
3182
3183   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3184   if (syms == NULL)
3185     return -1;
3186
3187   if (!relocatable && static_count != 0 && dyn_count != 0)
3188     {
3189       /* Use both symbol tables.  */
3190       memcpy (syms, static_syms, static_count * sizeof (*syms));
3191       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3192     }
3193   else if (!relocatable && static_count == 0)
3194     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3195   else
3196     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3197
3198   synthetic_relocatable = relocatable;
3199   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3200
3201   if (!relocatable && symcount > 1)
3202     {
3203       long j;
3204       /* Trim duplicate syms, since we may have merged the normal and
3205          dynamic symbols.  Actually, we only care about syms that have
3206          different values, so trim any with the same value.  */
3207       for (i = 1, j = 1; i < symcount; ++i)
3208         if (syms[i - 1]->value + syms[i - 1]->section->vma
3209             != syms[i]->value + syms[i]->section->vma)
3210           syms[j++] = syms[i];
3211       symcount = j;
3212     }
3213
3214   i = 0;
3215   if (strcmp (syms[i]->section->name, ".opd") == 0)
3216     ++i;
3217   codesecsym = i;
3218
3219   for (; i < symcount; ++i)
3220     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3221          != (SEC_CODE | SEC_ALLOC))
3222         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3223       break;
3224   codesecsymend = i;
3225
3226   for (; i < symcount; ++i)
3227     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3228       break;
3229   secsymend = i;
3230
3231   for (; i < symcount; ++i)
3232     if (strcmp (syms[i]->section->name, ".opd") != 0)
3233       break;
3234   opdsymend = i;
3235
3236   for (; i < symcount; ++i)
3237     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3238         != (SEC_CODE | SEC_ALLOC))
3239       break;
3240   symcount = i;
3241
3242   count = 0;
3243
3244   if (relocatable)
3245     {
3246       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3247       arelent *r;
3248       size_t size;
3249       long relcount;
3250
3251       if (opdsymend == secsymend)
3252         goto done;
3253
3254       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3255       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3256       if (relcount == 0)
3257         goto done;
3258
3259       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3260         {
3261           count = -1;
3262           goto done;
3263         }
3264
3265       size = 0;
3266       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3267         {
3268           asymbol *sym;
3269
3270           while (r < opd->relocation + relcount
3271                  && r->address < syms[i]->value + opd->vma)
3272             ++r;
3273
3274           if (r == opd->relocation + relcount)
3275             break;
3276
3277           if (r->address != syms[i]->value + opd->vma)
3278             continue;
3279
3280           if (r->howto->type != R_PPC64_ADDR64)
3281             continue;
3282
3283           sym = *r->sym_ptr_ptr;
3284           if (!sym_exists_at (syms, opdsymend, symcount,
3285                               sym->section->id, sym->value + r->addend))
3286             {
3287               ++count;
3288               size += sizeof (asymbol);
3289               size += strlen (syms[i]->name) + 2;
3290             }
3291         }
3292
3293       if (size == 0)
3294         goto done;
3295       s = *ret = bfd_malloc (size);
3296       if (s == NULL)
3297         {
3298           count = -1;
3299           goto done;
3300         }
3301
3302       names = (char *) (s + count);
3303
3304       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3305         {
3306           asymbol *sym;
3307
3308           while (r < opd->relocation + relcount
3309                  && r->address < syms[i]->value + opd->vma)
3310             ++r;
3311
3312           if (r == opd->relocation + relcount)
3313             break;
3314
3315           if (r->address != syms[i]->value + opd->vma)
3316             continue;
3317
3318           if (r->howto->type != R_PPC64_ADDR64)
3319             continue;
3320
3321           sym = *r->sym_ptr_ptr;
3322           if (!sym_exists_at (syms, opdsymend, symcount,
3323                               sym->section->id, sym->value + r->addend))
3324             {
3325               size_t len;
3326
3327               *s = *syms[i];
3328               s->flags |= BSF_SYNTHETIC;
3329               s->section = sym->section;
3330               s->value = sym->value + r->addend;
3331               s->name = names;
3332               *names++ = '.';
3333               len = strlen (syms[i]->name);
3334               memcpy (names, syms[i]->name, len + 1);
3335               names += len + 1;
3336               /* Have udata.p point back to the original symbol this
3337                  synthetic symbol was derived from.  */
3338               s->udata.p = syms[i];
3339               s++;
3340             }
3341         }
3342     }
3343   else
3344     {
3345       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3346       bfd_byte *contents = NULL;
3347       size_t size;
3348       long plt_count = 0;
3349       bfd_vma glink_vma = 0, resolv_vma = 0;
3350       asection *dynamic, *glink = NULL, *relplt = NULL;
3351       arelent *p;
3352
3353       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3354         {
3355         free_contents_and_exit_err:
3356           count = -1;
3357         free_contents_and_exit:
3358           if (contents)
3359             free (contents);
3360           goto done;
3361         }
3362
3363       size = 0;
3364       for (i = secsymend; i < opdsymend; ++i)
3365         {
3366           bfd_vma ent;
3367
3368           /* Ignore bogus symbols.  */
3369           if (syms[i]->value > opd->size - 8)
3370             continue;
3371
3372           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3373           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3374             {
3375               ++count;
3376               size += sizeof (asymbol);
3377               size += strlen (syms[i]->name) + 2;
3378             }
3379         }
3380
3381       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3382       if (dyn_count != 0
3383           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3384         {
3385           bfd_byte *dynbuf, *extdyn, *extdynend;
3386           size_t extdynsize;
3387           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3388
3389           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3390             goto free_contents_and_exit_err;
3391
3392           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3393           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3394
3395           extdyn = dynbuf;
3396           extdynend = extdyn + dynamic->size;
3397           for (; extdyn < extdynend; extdyn += extdynsize)
3398             {
3399               Elf_Internal_Dyn dyn;
3400               (*swap_dyn_in) (abfd, extdyn, &dyn);
3401
3402               if (dyn.d_tag == DT_NULL)
3403                 break;
3404
3405               if (dyn.d_tag == DT_PPC64_GLINK)
3406                 {
3407                   /* The first glink stub starts at offset 32; see
3408                      comment in ppc64_elf_finish_dynamic_sections. */
3409                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3410                   /* The .glink section usually does not survive the final
3411                      link; search for the section (usually .text) where the
3412                      glink stubs now reside.  */
3413                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3414                                                 &glink_vma);
3415                   break;
3416                 }
3417             }
3418
3419           free (dynbuf);
3420         }
3421
3422       if (glink != NULL)
3423         {
3424           /* Determine __glink trampoline by reading the relative branch
3425              from the first glink stub.  */
3426           bfd_byte buf[4];
3427           unsigned int off = 0;
3428
3429           while (bfd_get_section_contents (abfd, glink, buf,
3430                                            glink_vma + off - glink->vma, 4))
3431             {
3432               unsigned int insn = bfd_get_32 (abfd, buf);
3433               insn ^= B_DOT;
3434               if ((insn & ~0x3fffffc) == 0)
3435                 {
3436                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3437                   break;
3438                 }
3439               off += 4;
3440               if (off > 4)
3441                 break;
3442             }
3443
3444           if (resolv_vma)
3445             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3446
3447           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3448           if (relplt != NULL)
3449             {
3450               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3451               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3452                 goto free_contents_and_exit_err;
3453
3454               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3455               size += plt_count * sizeof (asymbol);
3456
3457               p = relplt->relocation;
3458               for (i = 0; i < plt_count; i++, p++)
3459                 {
3460                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3461                   if (p->addend != 0)
3462                     size += sizeof ("+0x") - 1 + 16;
3463                 }
3464             }
3465         }
3466
3467       if (size == 0)
3468         goto free_contents_and_exit;
3469       s = *ret = bfd_malloc (size);
3470       if (s == NULL)
3471         goto free_contents_and_exit_err;
3472
3473       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3474
3475       for (i = secsymend; i < opdsymend; ++i)
3476         {
3477           bfd_vma ent;
3478
3479           if (syms[i]->value > opd->size - 8)
3480             continue;
3481
3482           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3483           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3484             {
3485               long lo, hi;
3486               size_t len;
3487               asection *sec = abfd->sections;
3488
3489               *s = *syms[i];
3490               lo = codesecsym;
3491               hi = codesecsymend;
3492               while (lo < hi)
3493                 {
3494                   long mid = (lo + hi) >> 1;
3495                   if (syms[mid]->section->vma < ent)
3496                     lo = mid + 1;
3497                   else if (syms[mid]->section->vma > ent)
3498                     hi = mid;
3499                   else
3500                     {
3501                       sec = syms[mid]->section;
3502                       break;
3503                     }
3504                 }
3505
3506               if (lo >= hi && lo > codesecsym)
3507                 sec = syms[lo - 1]->section;
3508
3509               for (; sec != NULL; sec = sec->next)
3510                 {
3511                   if (sec->vma > ent)
3512                     break;
3513                   /* SEC_LOAD may not be set if SEC is from a separate debug
3514                      info file.  */
3515                   if ((sec->flags & SEC_ALLOC) == 0)
3516                     break;
3517                   if ((sec->flags & SEC_CODE) != 0)
3518                     s->section = sec;
3519                 }
3520               s->flags |= BSF_SYNTHETIC;
3521               s->value = ent - s->section->vma;
3522               s->name = names;
3523               *names++ = '.';
3524               len = strlen (syms[i]->name);
3525               memcpy (names, syms[i]->name, len + 1);
3526               names += len + 1;
3527               /* Have udata.p point back to the original symbol this
3528                  synthetic symbol was derived from.  */
3529               s->udata.p = syms[i];
3530               s++;
3531             }
3532         }
3533       free (contents);
3534
3535       if (glink != NULL && relplt != NULL)
3536         {
3537           if (resolv_vma)
3538             {
3539               /* Add a symbol for the main glink trampoline.  */
3540               memset (s, 0, sizeof *s);
3541               s->the_bfd = abfd;
3542               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3543               s->section = glink;
3544               s->value = resolv_vma - glink->vma;
3545               s->name = names;
3546               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3547               names += sizeof ("__glink_PLTresolve");
3548               s++;
3549               count++;
3550             }
3551
3552           /* FIXME: It would be very much nicer to put sym@plt on the
3553              stub rather than on the glink branch table entry.  The
3554              objdump disassembler would then use a sensible symbol
3555              name on plt calls.  The difficulty in doing so is
3556              a) finding the stubs, and,
3557              b) matching stubs against plt entries, and,
3558              c) there can be multiple stubs for a given plt entry.
3559
3560              Solving (a) could be done by code scanning, but older
3561              ppc64 binaries used different stubs to current code.
3562              (b) is the tricky one since you need to known the toc
3563              pointer for at least one function that uses a pic stub to
3564              be able to calculate the plt address referenced.
3565              (c) means gdb would need to set multiple breakpoints (or
3566              find the glink branch itself) when setting breakpoints
3567              for pending shared library loads.  */
3568           p = relplt->relocation;
3569           for (i = 0; i < plt_count; i++, p++)
3570             {
3571               size_t len;
3572
3573               *s = **p->sym_ptr_ptr;
3574               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3575                  we are defining a symbol, ensure one of them is set.  */
3576               if ((s->flags & BSF_LOCAL) == 0)
3577                 s->flags |= BSF_GLOBAL;
3578               s->flags |= BSF_SYNTHETIC;
3579               s->section = glink;
3580               s->value = glink_vma - glink->vma;
3581               s->name = names;
3582               s->udata.p = NULL;
3583               len = strlen ((*p->sym_ptr_ptr)->name);
3584               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3585               names += len;
3586               if (p->addend != 0)
3587                 {
3588                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3589                   names += sizeof ("+0x") - 1;
3590                   bfd_sprintf_vma (abfd, names, p->addend);
3591                   names += strlen (names);
3592                 }
3593               memcpy (names, "@plt", sizeof ("@plt"));
3594               names += sizeof ("@plt");
3595               s++;
3596               if (abi < 2)
3597                 {
3598                   glink_vma += 8;
3599                   if (i >= 0x8000)
3600                     glink_vma += 4;
3601                 }
3602               else
3603                 glink_vma += 4;
3604             }
3605           count += plt_count;
3606         }
3607     }
3608
3609  done:
3610   free (syms);
3611   return count;
3612 }
3613 \f
3614 /* The following functions are specific to the ELF linker, while
3615    functions above are used generally.  Those named ppc64_elf_* are
3616    called by the main ELF linker code.  They appear in this file more
3617    or less in the order in which they are called.  eg.
3618    ppc64_elf_check_relocs is called early in the link process,
3619    ppc64_elf_finish_dynamic_sections is one of the last functions
3620    called.
3621
3622    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3623    functions have both a function code symbol and a function descriptor
3624    symbol.  A call to foo in a relocatable object file looks like:
3625
3626    .            .text
3627    .    x:
3628    .            bl      .foo
3629    .            nop
3630
3631    The function definition in another object file might be:
3632
3633    .            .section .opd
3634    .    foo:    .quad   .foo
3635    .            .quad   .TOC.@tocbase
3636    .            .quad   0
3637    .
3638    .            .text
3639    .    .foo:   blr
3640
3641    When the linker resolves the call during a static link, the branch
3642    unsurprisingly just goes to .foo and the .opd information is unused.
3643    If the function definition is in a shared library, things are a little
3644    different:  The call goes via a plt call stub, the opd information gets
3645    copied to the plt, and the linker patches the nop.
3646
3647    .    x:
3648    .            bl      .foo_stub
3649    .            ld      2,40(1)
3650    .
3651    .
3652    .    .foo_stub:
3653    .            std     2,40(1)                 # in practice, the call stub
3654    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3655    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3656    .            ld      12,0(11)
3657    .            ld      2,8(11)
3658    .            mtctr   12
3659    .            ld      11,16(11)
3660    .            bctr
3661    .
3662    .            .section .plt
3663    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3664
3665    The "reloc ()" notation is supposed to indicate that the linker emits
3666    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3667    copying.
3668
3669    What are the difficulties here?  Well, firstly, the relocations
3670    examined by the linker in check_relocs are against the function code
3671    sym .foo, while the dynamic relocation in the plt is emitted against
3672    the function descriptor symbol, foo.  Somewhere along the line, we need
3673    to carefully copy dynamic link information from one symbol to the other.
3674    Secondly, the generic part of the elf linker will make .foo a dynamic
3675    symbol as is normal for most other backends.  We need foo dynamic
3676    instead, at least for an application final link.  However, when
3677    creating a shared library containing foo, we need to have both symbols
3678    dynamic so that references to .foo are satisfied during the early
3679    stages of linking.  Otherwise the linker might decide to pull in a
3680    definition from some other object, eg. a static library.
3681
3682    Update: As of August 2004, we support a new convention.  Function
3683    calls may use the function descriptor symbol, ie. "bl foo".  This
3684    behaves exactly as "bl .foo".  */
3685
3686 /* Of those relocs that might be copied as dynamic relocs, this function
3687    selects those that must be copied when linking a shared library,
3688    even when the symbol is local.  */
3689
3690 static int
3691 must_be_dyn_reloc (struct bfd_link_info *info,
3692                    enum elf_ppc64_reloc_type r_type)
3693 {
3694   switch (r_type)
3695     {
3696     default:
3697       return 1;
3698
3699     case R_PPC64_REL32:
3700     case R_PPC64_REL64:
3701     case R_PPC64_REL30:
3702       return 0;
3703
3704     case R_PPC64_TPREL16:
3705     case R_PPC64_TPREL16_LO:
3706     case R_PPC64_TPREL16_HI:
3707     case R_PPC64_TPREL16_HA:
3708     case R_PPC64_TPREL16_DS:
3709     case R_PPC64_TPREL16_LO_DS:
3710     case R_PPC64_TPREL16_HIGH:
3711     case R_PPC64_TPREL16_HIGHA:
3712     case R_PPC64_TPREL16_HIGHER:
3713     case R_PPC64_TPREL16_HIGHERA:
3714     case R_PPC64_TPREL16_HIGHEST:
3715     case R_PPC64_TPREL16_HIGHESTA:
3716     case R_PPC64_TPREL64:
3717       return !bfd_link_executable (info);
3718     }
3719 }
3720
3721 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3722    copying dynamic variables from a shared lib into an app's dynbss
3723    section, and instead use a dynamic relocation to point into the
3724    shared lib.  With code that gcc generates, it's vital that this be
3725    enabled;  In the PowerPC64 ABI, the address of a function is actually
3726    the address of a function descriptor, which resides in the .opd
3727    section.  gcc uses the descriptor directly rather than going via the
3728    GOT as some other ABI's do, which means that initialized function
3729    pointers must reference the descriptor.  Thus, a function pointer
3730    initialized to the address of a function in a shared library will
3731    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3732    redefines the function descriptor symbol to point to the copy.  This
3733    presents a problem as a plt entry for that function is also
3734    initialized from the function descriptor symbol and the copy reloc
3735    may not be initialized first.  */
3736 #define ELIMINATE_COPY_RELOCS 1
3737
3738 /* Section name for stubs is the associated section name plus this
3739    string.  */
3740 #define STUB_SUFFIX ".stub"
3741
3742 /* Linker stubs.
3743    ppc_stub_long_branch:
3744    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3745    destination, but a 24 bit branch in a stub section will reach.
3746    .    b       dest
3747
3748    ppc_stub_plt_branch:
3749    Similar to the above, but a 24 bit branch in the stub section won't
3750    reach its destination.
3751    .    addis   %r11,%r2,xxx@toc@ha
3752    .    ld      %r12,xxx@toc@l(%r11)
3753    .    mtctr   %r12
3754    .    bctr
3755
3756    ppc_stub_plt_call:
3757    Used to call a function in a shared library.  If it so happens that
3758    the plt entry referenced crosses a 64k boundary, then an extra
3759    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3760    .    std     %r2,40(%r1)
3761    .    addis   %r11,%r2,xxx@toc@ha
3762    .    ld      %r12,xxx+0@toc@l(%r11)
3763    .    mtctr   %r12
3764    .    ld      %r2,xxx+8@toc@l(%r11)
3765    .    ld      %r11,xxx+16@toc@l(%r11)
3766    .    bctr
3767
3768    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3769    code to adjust the value and save r2 to support multiple toc sections.
3770    A ppc_stub_long_branch with an r2 offset looks like:
3771    .    std     %r2,40(%r1)
3772    .    addis   %r2,%r2,off@ha
3773    .    addi    %r2,%r2,off@l
3774    .    b       dest
3775
3776    A ppc_stub_plt_branch with an r2 offset looks like:
3777    .    std     %r2,40(%r1)
3778    .    addis   %r11,%r2,xxx@toc@ha
3779    .    ld      %r12,xxx@toc@l(%r11)
3780    .    addis   %r2,%r2,off@ha
3781    .    addi    %r2,%r2,off@l
3782    .    mtctr   %r12
3783    .    bctr
3784
3785    In cases where the "addis" instruction would add zero, the "addis" is
3786    omitted and following instructions modified slightly in some cases.
3787 */
3788
3789 enum ppc_stub_type {
3790   ppc_stub_none,
3791   ppc_stub_long_branch,
3792   ppc_stub_long_branch_r2off,
3793   ppc_stub_plt_branch,
3794   ppc_stub_plt_branch_r2off,
3795   ppc_stub_plt_call,
3796   ppc_stub_plt_call_r2save,
3797   ppc_stub_global_entry,
3798   ppc_stub_save_res
3799 };
3800
3801 /* Information on stub grouping.  */
3802 struct map_stub
3803 {
3804   /* The stub section.  */
3805   asection *stub_sec;
3806   /* This is the section to which stubs in the group will be attached.  */
3807   asection *link_sec;
3808   /* Next group.  */
3809   struct map_stub *next;
3810   /* Whether to emit a copy of register save/restore functions in this
3811      group.  */
3812   int needs_save_res;
3813 };
3814
3815 struct ppc_stub_hash_entry {
3816
3817   /* Base hash table entry structure.  */
3818   struct bfd_hash_entry root;
3819
3820   enum ppc_stub_type stub_type;
3821
3822   /* Group information.  */
3823   struct map_stub *group;
3824
3825   /* Offset within stub_sec of the beginning of this stub.  */
3826   bfd_vma stub_offset;
3827
3828   /* Given the symbol's value and its section we can determine its final
3829      value when building the stubs (so the stub knows where to jump.  */
3830   bfd_vma target_value;
3831   asection *target_section;
3832
3833   /* The symbol table entry, if any, that this was derived from.  */
3834   struct ppc_link_hash_entry *h;
3835   struct plt_entry *plt_ent;
3836
3837   /* Symbol st_other.  */
3838   unsigned char other;
3839 };
3840
3841 struct ppc_branch_hash_entry {
3842
3843   /* Base hash table entry structure.  */
3844   struct bfd_hash_entry root;
3845
3846   /* Offset within branch lookup table.  */
3847   unsigned int offset;
3848
3849   /* Generation marker.  */
3850   unsigned int iter;
3851 };
3852
3853 /* Used to track dynamic relocations for local symbols.  */
3854 struct ppc_dyn_relocs
3855 {
3856   struct ppc_dyn_relocs *next;
3857
3858   /* The input section of the reloc.  */
3859   asection *sec;
3860
3861   /* Total number of relocs copied for the input section.  */
3862   unsigned int count : 31;
3863
3864   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3865   unsigned int ifunc : 1;
3866 };
3867
3868 struct ppc_link_hash_entry
3869 {
3870   struct elf_link_hash_entry elf;
3871
3872   union {
3873     /* A pointer to the most recently used stub hash entry against this
3874        symbol.  */
3875     struct ppc_stub_hash_entry *stub_cache;
3876
3877     /* A pointer to the next symbol starting with a '.'  */
3878     struct ppc_link_hash_entry *next_dot_sym;
3879   } u;
3880
3881   /* Track dynamic relocs copied for this symbol.  */
3882   struct elf_dyn_relocs *dyn_relocs;
3883
3884   /* Link between function code and descriptor symbols.  */
3885   struct ppc_link_hash_entry *oh;
3886
3887   /* Flag function code and descriptor symbols.  */
3888   unsigned int is_func:1;
3889   unsigned int is_func_descriptor:1;
3890   unsigned int fake:1;
3891
3892   /* Whether global opd/toc sym has been adjusted or not.
3893      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3894      should be set for all globals defined in any opd/toc section.  */
3895   unsigned int adjust_done:1;
3896
3897   /* Set if we twiddled this symbol to weak at some stage.  */
3898   unsigned int was_undefined:1;
3899
3900   /* Set if this is an out-of-line register save/restore function,
3901      with non-standard calling convention.  */
3902   unsigned int save_res:1;
3903
3904   /* Contexts in which symbol is used in the GOT (or TOC).
3905      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3906      corresponding relocs are encountered during check_relocs.
3907      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3908      indicate the corresponding GOT entry type is not needed.
3909      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3910      a TPREL one.  We use a separate flag rather than setting TPREL
3911      just for convenience in distinguishing the two cases.  */
3912 #define TLS_GD           1      /* GD reloc. */
3913 #define TLS_LD           2      /* LD reloc. */
3914 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3915 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3916 #define TLS_TLS         16      /* Any TLS reloc.  */
3917 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3918 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3919 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3920   unsigned char tls_mask;
3921 };
3922
3923 /* ppc64 ELF linker hash table.  */
3924
3925 struct ppc_link_hash_table
3926 {
3927   struct elf_link_hash_table elf;
3928
3929   /* The stub hash table.  */
3930   struct bfd_hash_table stub_hash_table;
3931
3932   /* Another hash table for plt_branch stubs.  */
3933   struct bfd_hash_table branch_hash_table;
3934
3935   /* Hash table for function prologue tocsave.  */
3936   htab_t tocsave_htab;
3937
3938   /* Various options and other info passed from the linker.  */
3939   struct ppc64_elf_params *params;
3940
3941   /* The size of sec_info below.  */
3942   unsigned int sec_info_arr_size;
3943
3944   /* Per-section array of extra section info.  Done this way rather
3945      than as part of ppc64_elf_section_data so we have the info for
3946      non-ppc64 sections.  */
3947   struct
3948   {
3949     /* Along with elf_gp, specifies the TOC pointer used by this section.  */
3950     bfd_vma toc_off;
3951
3952     union
3953     {
3954       /* The section group that this section belongs to.  */
3955       struct map_stub *group;
3956       /* A temp section list pointer.  */
3957       asection *list;
3958     } u;
3959   } *sec_info;
3960
3961   /* Linked list of groups.  */
3962   struct map_stub *group;
3963
3964   /* Temp used when calculating TOC pointers.  */
3965   bfd_vma toc_curr;
3966   bfd *toc_bfd;
3967   asection *toc_first_sec;
3968
3969   /* Used when adding symbols.  */
3970   struct ppc_link_hash_entry *dot_syms;
3971
3972   /* Shortcuts to get to dynamic linker sections.  */
3973   asection *dynbss;
3974   asection *relbss;
3975   asection *glink;
3976   asection *sfpr;
3977   asection *brlt;
3978   asection *relbrlt;
3979   asection *glink_eh_frame;
3980
3981   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3982   struct ppc_link_hash_entry *tls_get_addr;
3983   struct ppc_link_hash_entry *tls_get_addr_fd;
3984
3985   /* The size of reliplt used by got entry relocs.  */
3986   bfd_size_type got_reli_size;
3987
3988   /* Statistics.  */
3989   unsigned long stub_count[ppc_stub_global_entry];
3990
3991   /* Number of stubs against global syms.  */
3992   unsigned long stub_globals;
3993
3994   /* Set if we're linking code with function descriptors.  */
3995   unsigned int opd_abi:1;
3996
3997   /* Support for multiple toc sections.  */
3998   unsigned int do_multi_toc:1;
3999   unsigned int multi_toc_needed:1;
4000   unsigned int second_toc_pass:1;
4001   unsigned int do_toc_opt:1;
4002
4003   /* Set on error.  */
4004   unsigned int stub_error:1;
4005
4006   /* Temp used by ppc64_elf_before_check_relocs.  */
4007   unsigned int twiddled_syms:1;
4008
4009   /* Incremented every time we size stubs.  */
4010   unsigned int stub_iteration;
4011
4012   /* Small local sym cache.  */
4013   struct sym_cache sym_cache;
4014 };
4015
4016 /* Rename some of the generic section flags to better document how they
4017    are used here.  */
4018
4019 /* Nonzero if this section has TLS related relocations.  */
4020 #define has_tls_reloc sec_flg0
4021
4022 /* Nonzero if this section has a call to __tls_get_addr.  */
4023 #define has_tls_get_addr_call sec_flg1
4024
4025 /* Nonzero if this section has any toc or got relocs.  */
4026 #define has_toc_reloc sec_flg2
4027
4028 /* Nonzero if this section has a call to another section that uses
4029    the toc or got.  */
4030 #define makes_toc_func_call sec_flg3
4031
4032 /* Recursion protection when determining above flag.  */
4033 #define call_check_in_progress sec_flg4
4034 #define call_check_done sec_flg5
4035
4036 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4037
4038 #define ppc_hash_table(p) \
4039   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4040   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4041
4042 #define ppc_stub_hash_lookup(table, string, create, copy) \
4043   ((struct ppc_stub_hash_entry *) \
4044    bfd_hash_lookup ((table), (string), (create), (copy)))
4045
4046 #define ppc_branch_hash_lookup(table, string, create, copy) \
4047   ((struct ppc_branch_hash_entry *) \
4048    bfd_hash_lookup ((table), (string), (create), (copy)))
4049
4050 /* Create an entry in the stub hash table.  */
4051
4052 static struct bfd_hash_entry *
4053 stub_hash_newfunc (struct bfd_hash_entry *entry,
4054                    struct bfd_hash_table *table,
4055                    const char *string)
4056 {
4057   /* Allocate the structure if it has not already been allocated by a
4058      subclass.  */
4059   if (entry == NULL)
4060     {
4061       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4062       if (entry == NULL)
4063         return entry;
4064     }
4065
4066   /* Call the allocation method of the superclass.  */
4067   entry = bfd_hash_newfunc (entry, table, string);
4068   if (entry != NULL)
4069     {
4070       struct ppc_stub_hash_entry *eh;
4071
4072       /* Initialize the local fields.  */
4073       eh = (struct ppc_stub_hash_entry *) entry;
4074       eh->stub_type = ppc_stub_none;
4075       eh->group = NULL;
4076       eh->stub_offset = 0;
4077       eh->target_value = 0;
4078       eh->target_section = NULL;
4079       eh->h = NULL;
4080       eh->plt_ent = NULL;
4081       eh->other = 0;
4082     }
4083
4084   return entry;
4085 }
4086
4087 /* Create an entry in the branch hash table.  */
4088
4089 static struct bfd_hash_entry *
4090 branch_hash_newfunc (struct bfd_hash_entry *entry,
4091                      struct bfd_hash_table *table,
4092                      const char *string)
4093 {
4094   /* Allocate the structure if it has not already been allocated by a
4095      subclass.  */
4096   if (entry == NULL)
4097     {
4098       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4099       if (entry == NULL)
4100         return entry;
4101     }
4102
4103   /* Call the allocation method of the superclass.  */
4104   entry = bfd_hash_newfunc (entry, table, string);
4105   if (entry != NULL)
4106     {
4107       struct ppc_branch_hash_entry *eh;
4108
4109       /* Initialize the local fields.  */
4110       eh = (struct ppc_branch_hash_entry *) entry;
4111       eh->offset = 0;
4112       eh->iter = 0;
4113     }
4114
4115   return entry;
4116 }
4117
4118 /* Create an entry in a ppc64 ELF linker hash table.  */
4119
4120 static struct bfd_hash_entry *
4121 link_hash_newfunc (struct bfd_hash_entry *entry,
4122                    struct bfd_hash_table *table,
4123                    const char *string)
4124 {
4125   /* Allocate the structure if it has not already been allocated by a
4126      subclass.  */
4127   if (entry == NULL)
4128     {
4129       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4130       if (entry == NULL)
4131         return entry;
4132     }
4133
4134   /* Call the allocation method of the superclass.  */
4135   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4136   if (entry != NULL)
4137     {
4138       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4139
4140       memset (&eh->u.stub_cache, 0,
4141               (sizeof (struct ppc_link_hash_entry)
4142                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4143
4144       /* When making function calls, old ABI code references function entry
4145          points (dot symbols), while new ABI code references the function
4146          descriptor symbol.  We need to make any combination of reference and
4147          definition work together, without breaking archive linking.
4148
4149          For a defined function "foo" and an undefined call to "bar":
4150          An old object defines "foo" and ".foo", references ".bar" (possibly
4151          "bar" too).
4152          A new object defines "foo" and references "bar".
4153
4154          A new object thus has no problem with its undefined symbols being
4155          satisfied by definitions in an old object.  On the other hand, the
4156          old object won't have ".bar" satisfied by a new object.
4157
4158          Keep a list of newly added dot-symbols.  */
4159
4160       if (string[0] == '.')
4161         {
4162           struct ppc_link_hash_table *htab;
4163
4164           htab = (struct ppc_link_hash_table *) table;
4165           eh->u.next_dot_sym = htab->dot_syms;
4166           htab->dot_syms = eh;
4167         }
4168     }
4169
4170   return entry;
4171 }
4172
4173 struct tocsave_entry {
4174   asection *sec;
4175   bfd_vma offset;
4176 };
4177
4178 static hashval_t
4179 tocsave_htab_hash (const void *p)
4180 {
4181   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4182   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4183 }
4184
4185 static int
4186 tocsave_htab_eq (const void *p1, const void *p2)
4187 {
4188   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4189   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4190   return e1->sec == e2->sec && e1->offset == e2->offset;
4191 }
4192
4193 /* Destroy a ppc64 ELF linker hash table.  */
4194
4195 static void
4196 ppc64_elf_link_hash_table_free (bfd *obfd)
4197 {
4198   struct ppc_link_hash_table *htab;
4199
4200   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4201   if (htab->tocsave_htab)
4202     htab_delete (htab->tocsave_htab);
4203   bfd_hash_table_free (&htab->branch_hash_table);
4204   bfd_hash_table_free (&htab->stub_hash_table);
4205   _bfd_elf_link_hash_table_free (obfd);
4206 }
4207
4208 /* Create a ppc64 ELF linker hash table.  */
4209
4210 static struct bfd_link_hash_table *
4211 ppc64_elf_link_hash_table_create (bfd *abfd)
4212 {
4213   struct ppc_link_hash_table *htab;
4214   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4215
4216   htab = bfd_zmalloc (amt);
4217   if (htab == NULL)
4218     return NULL;
4219
4220   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4221                                       sizeof (struct ppc_link_hash_entry),
4222                                       PPC64_ELF_DATA))
4223     {
4224       free (htab);
4225       return NULL;
4226     }
4227
4228   /* Init the stub hash table too.  */
4229   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4230                             sizeof (struct ppc_stub_hash_entry)))
4231     {
4232       _bfd_elf_link_hash_table_free (abfd);
4233       return NULL;
4234     }
4235
4236   /* And the branch hash table.  */
4237   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4238                             sizeof (struct ppc_branch_hash_entry)))
4239     {
4240       bfd_hash_table_free (&htab->stub_hash_table);
4241       _bfd_elf_link_hash_table_free (abfd);
4242       return NULL;
4243     }
4244
4245   htab->tocsave_htab = htab_try_create (1024,
4246                                         tocsave_htab_hash,
4247                                         tocsave_htab_eq,
4248                                         NULL);
4249   if (htab->tocsave_htab == NULL)
4250     {
4251       ppc64_elf_link_hash_table_free (abfd);
4252       return NULL;
4253     }
4254   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4255
4256   /* Initializing two fields of the union is just cosmetic.  We really
4257      only care about glist, but when compiled on a 32-bit host the
4258      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4259      debugger inspection of these fields look nicer.  */
4260   htab->elf.init_got_refcount.refcount = 0;
4261   htab->elf.init_got_refcount.glist = NULL;
4262   htab->elf.init_plt_refcount.refcount = 0;
4263   htab->elf.init_plt_refcount.glist = NULL;
4264   htab->elf.init_got_offset.offset = 0;
4265   htab->elf.init_got_offset.glist = NULL;
4266   htab->elf.init_plt_offset.offset = 0;
4267   htab->elf.init_plt_offset.glist = NULL;
4268
4269   return &htab->elf.root;
4270 }
4271
4272 /* Create sections for linker generated code.  */
4273
4274 static bfd_boolean
4275 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4276 {
4277   struct ppc_link_hash_table *htab;
4278   flagword flags;
4279
4280   htab = ppc_hash_table (info);
4281
4282   /* Create .sfpr for code to save and restore fp regs.  */
4283   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4284            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4285   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4286                                                    flags);
4287   if (htab->sfpr == NULL
4288       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4289     return FALSE;
4290
4291   /* Create .glink for lazy dynamic linking support.  */
4292   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4293                                                     flags);
4294   if (htab->glink == NULL
4295       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4296     return FALSE;
4297
4298   if (!info->no_ld_generated_unwind_info)
4299     {
4300       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4301                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4302       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4303                                                                  ".eh_frame",
4304                                                                  flags);
4305       if (htab->glink_eh_frame == NULL
4306           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4307         return FALSE;
4308     }
4309
4310   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4311   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4312   if (htab->elf.iplt == NULL
4313       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4314     return FALSE;
4315
4316   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4317            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4318   htab->elf.irelplt
4319     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4320   if (htab->elf.irelplt == NULL
4321       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4322     return FALSE;
4323
4324   /* Create branch lookup table for plt_branch stubs.  */
4325   flags = (SEC_ALLOC | SEC_LOAD
4326            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4327   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4328                                                    flags);
4329   if (htab->brlt == NULL
4330       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4331     return FALSE;
4332
4333   if (!bfd_link_pic (info))
4334     return TRUE;
4335
4336   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4337            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4338   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4339                                                       ".rela.branch_lt",
4340                                                       flags);
4341   if (htab->relbrlt == NULL
4342       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4343     return FALSE;
4344
4345   return TRUE;
4346 }
4347
4348 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4349
4350 bfd_boolean
4351 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4352                          struct ppc64_elf_params *params)
4353 {
4354   struct ppc_link_hash_table *htab;
4355
4356   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4357
4358 /* Always hook our dynamic sections into the first bfd, which is the
4359    linker created stub bfd.  This ensures that the GOT header is at
4360    the start of the output TOC section.  */
4361   htab = ppc_hash_table (info);
4362   if (htab == NULL)
4363     return FALSE;
4364   htab->elf.dynobj = params->stub_bfd;
4365   htab->params = params;
4366
4367   if (bfd_link_relocatable (info))
4368     return TRUE;
4369
4370   return create_linkage_sections (htab->elf.dynobj, info);
4371 }
4372
4373 /* Build a name for an entry in the stub hash table.  */
4374
4375 static char *
4376 ppc_stub_name (const asection *input_section,
4377                const asection *sym_sec,
4378                const struct ppc_link_hash_entry *h,
4379                const Elf_Internal_Rela *rel)
4380 {
4381   char *stub_name;
4382   ssize_t len;
4383
4384   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4385      offsets from a sym as a branch target?  In fact, we could
4386      probably assume the addend is always zero.  */
4387   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4388
4389   if (h)
4390     {
4391       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4392       stub_name = bfd_malloc (len);
4393       if (stub_name == NULL)
4394         return stub_name;
4395
4396       len = sprintf (stub_name, "%08x.%s+%x",
4397                      input_section->id & 0xffffffff,
4398                      h->elf.root.root.string,
4399                      (int) rel->r_addend & 0xffffffff);
4400     }
4401   else
4402     {
4403       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4404       stub_name = bfd_malloc (len);
4405       if (stub_name == NULL)
4406         return stub_name;
4407
4408       len = sprintf (stub_name, "%08x.%x:%x+%x",
4409                      input_section->id & 0xffffffff,
4410                      sym_sec->id & 0xffffffff,
4411                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4412                      (int) rel->r_addend & 0xffffffff);
4413     }
4414   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4415     stub_name[len - 2] = 0;
4416   return stub_name;
4417 }
4418
4419 /* Look up an entry in the stub hash.  Stub entries are cached because
4420    creating the stub name takes a bit of time.  */
4421
4422 static struct ppc_stub_hash_entry *
4423 ppc_get_stub_entry (const asection *input_section,
4424                     const asection *sym_sec,
4425                     struct ppc_link_hash_entry *h,
4426                     const Elf_Internal_Rela *rel,
4427                     struct ppc_link_hash_table *htab)
4428 {
4429   struct ppc_stub_hash_entry *stub_entry;
4430   struct map_stub *group;
4431
4432   /* If this input section is part of a group of sections sharing one
4433      stub section, then use the id of the first section in the group.
4434      Stub names need to include a section id, as there may well be
4435      more than one stub used to reach say, printf, and we need to
4436      distinguish between them.  */
4437   group = htab->sec_info[input_section->id].u.group;
4438
4439   if (h != NULL && h->u.stub_cache != NULL
4440       && h->u.stub_cache->h == h
4441       && h->u.stub_cache->group == group)
4442     {
4443       stub_entry = h->u.stub_cache;
4444     }
4445   else
4446     {
4447       char *stub_name;
4448
4449       stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4450       if (stub_name == NULL)
4451         return NULL;
4452
4453       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4454                                          stub_name, FALSE, FALSE);
4455       if (h != NULL)
4456         h->u.stub_cache = stub_entry;
4457
4458       free (stub_name);
4459     }
4460
4461   return stub_entry;
4462 }
4463
4464 /* Add a new stub entry to the stub hash.  Not all fields of the new
4465    stub entry are initialised.  */
4466
4467 static struct ppc_stub_hash_entry *
4468 ppc_add_stub (const char *stub_name,
4469               asection *section,
4470               struct bfd_link_info *info)
4471 {
4472   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4473   struct map_stub *group;
4474   asection *link_sec;
4475   asection *stub_sec;
4476   struct ppc_stub_hash_entry *stub_entry;
4477
4478   group = htab->sec_info[section->id].u.group;
4479   link_sec = group->link_sec;
4480   stub_sec = group->stub_sec;
4481   if (stub_sec == NULL)
4482     {
4483       size_t namelen;
4484       bfd_size_type len;
4485       char *s_name;
4486
4487       namelen = strlen (link_sec->name);
4488       len = namelen + sizeof (STUB_SUFFIX);
4489       s_name = bfd_alloc (htab->params->stub_bfd, len);
4490       if (s_name == NULL)
4491         return NULL;
4492
4493       memcpy (s_name, link_sec->name, namelen);
4494       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4495       stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4496       if (stub_sec == NULL)
4497         return NULL;
4498       group->stub_sec = stub_sec;
4499     }
4500
4501   /* Enter this entry into the linker stub hash table.  */
4502   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4503                                      TRUE, FALSE);
4504   if (stub_entry == NULL)
4505     {
4506       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4507                               section->owner, stub_name);
4508       return NULL;
4509     }
4510
4511   stub_entry->group = group;
4512   stub_entry->stub_offset = 0;
4513   return stub_entry;
4514 }
4515
4516 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4517    not already done.  */
4518
4519 static bfd_boolean
4520 create_got_section (bfd *abfd, struct bfd_link_info *info)
4521 {
4522   asection *got, *relgot;
4523   flagword flags;
4524   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4525
4526   if (!is_ppc64_elf (abfd))
4527     return FALSE;
4528   if (htab == NULL)
4529     return FALSE;
4530
4531   if (!htab->elf.sgot
4532       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4533     return FALSE;
4534
4535   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4536            | SEC_LINKER_CREATED);
4537
4538   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4539   if (!got
4540       || !bfd_set_section_alignment (abfd, got, 3))
4541     return FALSE;
4542
4543   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4544                                                flags | SEC_READONLY);
4545   if (!relgot
4546       || ! bfd_set_section_alignment (abfd, relgot, 3))
4547     return FALSE;
4548
4549   ppc64_elf_tdata (abfd)->got = got;
4550   ppc64_elf_tdata (abfd)->relgot = relgot;
4551   return TRUE;
4552 }
4553
4554 /* Create the dynamic sections, and set up shortcuts.  */
4555
4556 static bfd_boolean
4557 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4558 {
4559   struct ppc_link_hash_table *htab;
4560
4561   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4562     return FALSE;
4563
4564   htab = ppc_hash_table (info);
4565   if (htab == NULL)
4566     return FALSE;
4567
4568   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4569   if (!bfd_link_pic (info))
4570     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4571
4572   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4573       || (!bfd_link_pic (info) && !htab->relbss))
4574     abort ();
4575
4576   return TRUE;
4577 }
4578
4579 /* Follow indirect and warning symbol links.  */
4580
4581 static inline struct bfd_link_hash_entry *
4582 follow_link (struct bfd_link_hash_entry *h)
4583 {
4584   while (h->type == bfd_link_hash_indirect
4585          || h->type == bfd_link_hash_warning)
4586     h = h->u.i.link;
4587   return h;
4588 }
4589
4590 static inline struct elf_link_hash_entry *
4591 elf_follow_link (struct elf_link_hash_entry *h)
4592 {
4593   return (struct elf_link_hash_entry *) follow_link (&h->root);
4594 }
4595
4596 static inline struct ppc_link_hash_entry *
4597 ppc_follow_link (struct ppc_link_hash_entry *h)
4598 {
4599   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4600 }
4601
4602 /* Merge PLT info on FROM with that on TO.  */
4603
4604 static void
4605 move_plt_plist (struct ppc_link_hash_entry *from,
4606                 struct ppc_link_hash_entry *to)
4607 {
4608   if (from->elf.plt.plist != NULL)
4609     {
4610       if (to->elf.plt.plist != NULL)
4611         {
4612           struct plt_entry **entp;
4613           struct plt_entry *ent;
4614
4615           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4616             {
4617               struct plt_entry *dent;
4618
4619               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4620                 if (dent->addend == ent->addend)
4621                   {
4622                     dent->plt.refcount += ent->plt.refcount;
4623                     *entp = ent->next;
4624                     break;
4625                   }
4626               if (dent == NULL)
4627                 entp = &ent->next;
4628             }
4629           *entp = to->elf.plt.plist;
4630         }
4631
4632       to->elf.plt.plist = from->elf.plt.plist;
4633       from->elf.plt.plist = NULL;
4634     }
4635 }
4636
4637 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4638
4639 static void
4640 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4641                                 struct elf_link_hash_entry *dir,
4642                                 struct elf_link_hash_entry *ind)
4643 {
4644   struct ppc_link_hash_entry *edir, *eind;
4645
4646   edir = (struct ppc_link_hash_entry *) dir;
4647   eind = (struct ppc_link_hash_entry *) ind;
4648
4649   edir->is_func |= eind->is_func;
4650   edir->is_func_descriptor |= eind->is_func_descriptor;
4651   edir->tls_mask |= eind->tls_mask;
4652   if (eind->oh != NULL)
4653     edir->oh = ppc_follow_link (eind->oh);
4654
4655   /* If called to transfer flags for a weakdef during processing
4656      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4657      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4658   if (!(ELIMINATE_COPY_RELOCS
4659         && eind->elf.root.type != bfd_link_hash_indirect
4660         && edir->elf.dynamic_adjusted))
4661     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4662
4663   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4664   edir->elf.ref_regular |= eind->elf.ref_regular;
4665   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4666   edir->elf.needs_plt |= eind->elf.needs_plt;
4667   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4668
4669   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4670   if (eind->dyn_relocs != NULL)
4671     {
4672       if (edir->dyn_relocs != NULL)
4673         {
4674           struct elf_dyn_relocs **pp;
4675           struct elf_dyn_relocs *p;
4676
4677           /* Add reloc counts against the indirect sym to the direct sym
4678              list.  Merge any entries against the same section.  */
4679           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4680             {
4681               struct elf_dyn_relocs *q;
4682
4683               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4684                 if (q->sec == p->sec)
4685                   {
4686                     q->pc_count += p->pc_count;
4687                     q->count += p->count;
4688                     *pp = p->next;
4689                     break;
4690                   }
4691               if (q == NULL)
4692                 pp = &p->next;
4693             }
4694           *pp = edir->dyn_relocs;
4695         }
4696
4697       edir->dyn_relocs = eind->dyn_relocs;
4698       eind->dyn_relocs = NULL;
4699     }
4700
4701   /* If we were called to copy over info for a weak sym, that's all.
4702      You might think dyn_relocs need not be copied over;  After all,
4703      both syms will be dynamic or both non-dynamic so we're just
4704      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4705      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4706      dyn_relocs in read-only sections, and it does so on what is the
4707      DIR sym here.  */
4708   if (eind->elf.root.type != bfd_link_hash_indirect)
4709     return;
4710
4711   /* Copy over got entries that we may have already seen to the
4712      symbol which just became indirect.  */
4713   if (eind->elf.got.glist != NULL)
4714     {
4715       if (edir->elf.got.glist != NULL)
4716         {
4717           struct got_entry **entp;
4718           struct got_entry *ent;
4719
4720           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4721             {
4722               struct got_entry *dent;
4723
4724               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4725                 if (dent->addend == ent->addend
4726                     && dent->owner == ent->owner
4727                     && dent->tls_type == ent->tls_type)
4728                   {
4729                     dent->got.refcount += ent->got.refcount;
4730                     *entp = ent->next;
4731                     break;
4732                   }
4733               if (dent == NULL)
4734                 entp = &ent->next;
4735             }
4736           *entp = edir->elf.got.glist;
4737         }
4738
4739       edir->elf.got.glist = eind->elf.got.glist;
4740       eind->elf.got.glist = NULL;
4741     }
4742
4743   /* And plt entries.  */
4744   move_plt_plist (eind, edir);
4745
4746   if (eind->elf.dynindx != -1)
4747     {
4748       if (edir->elf.dynindx != -1)
4749         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4750                                 edir->elf.dynstr_index);
4751       edir->elf.dynindx = eind->elf.dynindx;
4752       edir->elf.dynstr_index = eind->elf.dynstr_index;
4753       eind->elf.dynindx = -1;
4754       eind->elf.dynstr_index = 0;
4755     }
4756 }
4757
4758 /* Find the function descriptor hash entry from the given function code
4759    hash entry FH.  Link the entries via their OH fields.  */
4760
4761 static struct ppc_link_hash_entry *
4762 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4763 {
4764   struct ppc_link_hash_entry *fdh = fh->oh;
4765
4766   if (fdh == NULL)
4767     {
4768       const char *fd_name = fh->elf.root.root.string + 1;
4769
4770       fdh = (struct ppc_link_hash_entry *)
4771         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4772       if (fdh == NULL)
4773         return fdh;
4774
4775       fdh->is_func_descriptor = 1;
4776       fdh->oh = fh;
4777       fh->is_func = 1;
4778       fh->oh = fdh;
4779     }
4780
4781   return ppc_follow_link (fdh);
4782 }
4783
4784 /* Make a fake function descriptor sym for the code sym FH.  */
4785
4786 static struct ppc_link_hash_entry *
4787 make_fdh (struct bfd_link_info *info,
4788           struct ppc_link_hash_entry *fh)
4789 {
4790   bfd *abfd;
4791   asymbol *newsym;
4792   struct bfd_link_hash_entry *bh;
4793   struct ppc_link_hash_entry *fdh;
4794
4795   abfd = fh->elf.root.u.undef.abfd;
4796   newsym = bfd_make_empty_symbol (abfd);
4797   newsym->name = fh->elf.root.root.string + 1;
4798   newsym->section = bfd_und_section_ptr;
4799   newsym->value = 0;
4800   newsym->flags = BSF_WEAK;
4801
4802   bh = NULL;
4803   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4804                                          newsym->flags, newsym->section,
4805                                          newsym->value, NULL, FALSE, FALSE,
4806                                          &bh))
4807     return NULL;
4808
4809   fdh = (struct ppc_link_hash_entry *) bh;
4810   fdh->elf.non_elf = 0;
4811   fdh->fake = 1;
4812   fdh->is_func_descriptor = 1;
4813   fdh->oh = fh;
4814   fh->is_func = 1;
4815   fh->oh = fdh;
4816   return fdh;
4817 }
4818
4819 /* Fix function descriptor symbols defined in .opd sections to be
4820    function type.  */
4821
4822 static bfd_boolean
4823 ppc64_elf_add_symbol_hook (bfd *ibfd,
4824                            struct bfd_link_info *info,
4825                            Elf_Internal_Sym *isym,
4826                            const char **name,
4827                            flagword *flags ATTRIBUTE_UNUSED,
4828                            asection **sec,
4829                            bfd_vma *value)
4830 {
4831   if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4832        || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4833       && (ibfd->flags & DYNAMIC) == 0
4834       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4835     elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4836
4837   if (*sec != NULL
4838       && strcmp ((*sec)->name, ".opd") == 0)
4839     {
4840       asection *code_sec;
4841
4842       if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4843             || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4844         isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4845
4846       /* If the symbol is a function defined in .opd, and the function
4847          code is in a discarded group, let it appear to be undefined.  */
4848       if (!bfd_link_relocatable (info)
4849           && (*sec)->reloc_count != 0
4850           && opd_entry_value (*sec, *value, &code_sec, NULL,
4851                               FALSE) != (bfd_vma) -1
4852           && discarded_section (code_sec))
4853         {
4854           *sec = bfd_und_section_ptr;
4855           isym->st_shndx = SHN_UNDEF;
4856         }
4857     }
4858   else if (*sec != NULL
4859            && strcmp ((*sec)->name, ".toc") == 0
4860            && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4861     {
4862       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4863       if (htab != NULL)
4864         htab->params->object_in_toc = 1;
4865     }
4866
4867   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4868     {
4869       if (abiversion (ibfd) == 0)
4870         set_abiversion (ibfd, 2);
4871       else if (abiversion (ibfd) == 1)
4872         {
4873           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4874                                     " for ABI version 1\n"), name);
4875           bfd_set_error (bfd_error_bad_value);
4876           return FALSE;
4877         }
4878     }
4879
4880   return TRUE;
4881 }
4882
4883 /* Merge non-visibility st_other attributes: local entry point.  */
4884
4885 static void
4886 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4887                                   const Elf_Internal_Sym *isym,
4888                                   bfd_boolean definition,
4889                                   bfd_boolean dynamic)
4890 {
4891   if (definition && !dynamic)
4892     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4893                 | ELF_ST_VISIBILITY (h->other));
4894 }
4895
4896 /* This function makes an old ABI object reference to ".bar" cause the
4897    inclusion of a new ABI object archive that defines "bar".
4898    NAME is a symbol defined in an archive.  Return a symbol in the hash
4899    table that might be satisfied by the archive symbols.  */
4900
4901 static struct elf_link_hash_entry *
4902 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4903                                  struct bfd_link_info *info,
4904                                  const char *name)
4905 {
4906   struct elf_link_hash_entry *h;
4907   char *dot_name;
4908   size_t len;
4909
4910   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4911   if (h != NULL
4912       /* Don't return this sym if it is a fake function descriptor
4913          created by add_symbol_adjust.  */
4914       && !(h->root.type == bfd_link_hash_undefweak
4915            && ((struct ppc_link_hash_entry *) h)->fake))
4916     return h;
4917
4918   if (name[0] == '.')
4919     return h;
4920
4921   len = strlen (name);
4922   dot_name = bfd_alloc (abfd, len + 2);
4923   if (dot_name == NULL)
4924     return (struct elf_link_hash_entry *) 0 - 1;
4925   dot_name[0] = '.';
4926   memcpy (dot_name + 1, name, len + 1);
4927   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4928   bfd_release (abfd, dot_name);
4929   return h;
4930 }
4931
4932 /* This function satisfies all old ABI object references to ".bar" if a
4933    new ABI object defines "bar".  Well, at least, undefined dot symbols
4934    are made weak.  This stops later archive searches from including an
4935    object if we already have a function descriptor definition.  It also
4936    prevents the linker complaining about undefined symbols.
4937    We also check and correct mismatched symbol visibility here.  The
4938    most restrictive visibility of the function descriptor and the
4939    function entry symbol is used.  */
4940
4941 static bfd_boolean
4942 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4943 {
4944   struct ppc_link_hash_table *htab;
4945   struct ppc_link_hash_entry *fdh;
4946
4947   if (eh->elf.root.type == bfd_link_hash_indirect)
4948     return TRUE;
4949
4950   if (eh->elf.root.type == bfd_link_hash_warning)
4951     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4952
4953   if (eh->elf.root.root.string[0] != '.')
4954     abort ();
4955
4956   htab = ppc_hash_table (info);
4957   if (htab == NULL)
4958     return FALSE;
4959
4960   fdh = lookup_fdh (eh, htab);
4961   if (fdh == NULL)
4962     {
4963       if (!bfd_link_relocatable (info)
4964           && (eh->elf.root.type == bfd_link_hash_undefined
4965               || eh->elf.root.type == bfd_link_hash_undefweak)
4966           && eh->elf.ref_regular)
4967         {
4968           /* Make an undefweak function descriptor sym, which is enough to
4969              pull in an --as-needed shared lib, but won't cause link
4970              errors.  Archives are handled elsewhere.  */
4971           fdh = make_fdh (info, eh);
4972           if (fdh == NULL)
4973             return FALSE;
4974           fdh->elf.ref_regular = 1;
4975         }
4976     }
4977   else
4978     {
4979       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4980       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4981       if (entry_vis < descr_vis)
4982         fdh->elf.other += entry_vis - descr_vis;
4983       else if (entry_vis > descr_vis)
4984         eh->elf.other += descr_vis - entry_vis;
4985
4986       if ((fdh->elf.root.type == bfd_link_hash_defined
4987            || fdh->elf.root.type == bfd_link_hash_defweak)
4988           && eh->elf.root.type == bfd_link_hash_undefined)
4989         {
4990           eh->elf.root.type = bfd_link_hash_undefweak;
4991           eh->was_undefined = 1;
4992           htab->twiddled_syms = 1;
4993         }
4994     }
4995
4996   return TRUE;
4997 }
4998
4999 /* Set up opd section info and abiversion for IBFD, and process list
5000    of dot-symbols we made in link_hash_newfunc.  */
5001
5002 static bfd_boolean
5003 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5004 {
5005   struct ppc_link_hash_table *htab;
5006   struct ppc_link_hash_entry **p, *eh;
5007   asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5008
5009   if (opd != NULL && opd->size != 0)
5010     {
5011       if (abiversion (ibfd) == 0)
5012         set_abiversion (ibfd, 1);
5013       else if (abiversion (ibfd) == 2)
5014         {
5015           info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5016                                     " version %d\n"),
5017                                   ibfd, abiversion (ibfd));
5018           bfd_set_error (bfd_error_bad_value);
5019           return FALSE;
5020         }
5021
5022       if ((ibfd->flags & DYNAMIC) == 0
5023           && (opd->flags & SEC_RELOC) != 0
5024           && opd->reloc_count != 0
5025           && !bfd_is_abs_section (opd->output_section))
5026         {
5027           /* Garbage collection needs some extra help with .opd sections.
5028              We don't want to necessarily keep everything referenced by
5029              relocs in .opd, as that would keep all functions.  Instead,
5030              if we reference an .opd symbol (a function descriptor), we
5031              want to keep the function code symbol's section.  This is
5032              easy for global symbols, but for local syms we need to keep
5033              information about the associated function section.  */
5034           bfd_size_type amt;
5035           asection **opd_sym_map;
5036
5037           amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5038           opd_sym_map = bfd_zalloc (ibfd, amt);
5039           if (opd_sym_map == NULL)
5040             return FALSE;
5041           ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5042           BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5043           ppc64_elf_section_data (opd)->sec_type = sec_opd;
5044         }
5045     }
5046
5047   if (!is_ppc64_elf (info->output_bfd))
5048     return TRUE;
5049   htab = ppc_hash_table (info);
5050   if (htab == NULL)
5051     return FALSE;
5052
5053   /* For input files without an explicit abiversion in e_flags
5054      we should have flagged any with symbol st_other bits set
5055      as ELFv1 and above flagged those with .opd as ELFv2.
5056      Set the output abiversion if not yet set, and for any input
5057      still ambiguous, take its abiversion from the output.
5058      Differences in ABI are reported later.  */
5059   if (abiversion (info->output_bfd) == 0)
5060     set_abiversion (info->output_bfd, abiversion (ibfd));
5061   else if (abiversion (ibfd) == 0)
5062     set_abiversion (ibfd, abiversion (info->output_bfd));
5063
5064   p = &htab->dot_syms;
5065   while ((eh = *p) != NULL)
5066     {
5067       *p = NULL;
5068       if (&eh->elf == htab->elf.hgot)
5069         ;
5070       else if (htab->elf.hgot == NULL
5071                && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5072         htab->elf.hgot = &eh->elf;
5073       else if (!add_symbol_adjust (eh, info))
5074         return FALSE;
5075       p = &eh->u.next_dot_sym;
5076     }
5077
5078   /* Clear the list for non-ppc64 input files.  */
5079   p = &htab->dot_syms;
5080   while ((eh = *p) != NULL)
5081     {
5082       *p = NULL;
5083       p = &eh->u.next_dot_sym;
5084     }
5085
5086   /* We need to fix the undefs list for any syms we have twiddled to
5087      undef_weak.  */
5088   if (htab->twiddled_syms)
5089     {
5090       bfd_link_repair_undef_list (&htab->elf.root);
5091       htab->twiddled_syms = 0;
5092     }
5093   return TRUE;
5094 }
5095
5096 /* Undo hash table changes when an --as-needed input file is determined
5097    not to be needed.  */
5098
5099 static bfd_boolean
5100 ppc64_elf_notice_as_needed (bfd *ibfd,
5101                             struct bfd_link_info *info,
5102                             enum notice_asneeded_action act)
5103 {
5104   if (act == notice_not_needed)
5105     {
5106       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5107
5108       if (htab == NULL)
5109         return FALSE;
5110
5111       htab->dot_syms = NULL;
5112     }
5113   return _bfd_elf_notice_as_needed (ibfd, info, act);
5114 }
5115
5116 /* If --just-symbols against a final linked binary, then assume we need
5117    toc adjusting stubs when calling functions defined there.  */
5118
5119 static void
5120 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5121 {
5122   if ((sec->flags & SEC_CODE) != 0
5123       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5124       && is_ppc64_elf (sec->owner))
5125     {
5126       if (abiversion (sec->owner) >= 2
5127           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5128         sec->has_toc_reloc = 1;
5129     }
5130   _bfd_elf_link_just_syms (sec, info);
5131 }
5132
5133 static struct plt_entry **
5134 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5135                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5136 {
5137   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5138   struct plt_entry **local_plt;
5139   unsigned char *local_got_tls_masks;
5140
5141   if (local_got_ents == NULL)
5142     {
5143       bfd_size_type size = symtab_hdr->sh_info;
5144
5145       size *= (sizeof (*local_got_ents)
5146                + sizeof (*local_plt)
5147                + sizeof (*local_got_tls_masks));
5148       local_got_ents = bfd_zalloc (abfd, size);
5149       if (local_got_ents == NULL)
5150         return NULL;
5151       elf_local_got_ents (abfd) = local_got_ents;
5152     }
5153
5154   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5155     {
5156       struct got_entry *ent;
5157
5158       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5159         if (ent->addend == r_addend
5160             && ent->owner == abfd
5161             && ent->tls_type == tls_type)
5162           break;
5163       if (ent == NULL)
5164         {
5165           bfd_size_type amt = sizeof (*ent);
5166           ent = bfd_alloc (abfd, amt);
5167           if (ent == NULL)
5168             return FALSE;
5169           ent->next = local_got_ents[r_symndx];
5170           ent->addend = r_addend;
5171           ent->owner = abfd;
5172           ent->tls_type = tls_type;
5173           ent->is_indirect = FALSE;
5174           ent->got.refcount = 0;
5175           local_got_ents[r_symndx] = ent;
5176         }
5177       ent->got.refcount += 1;
5178     }
5179
5180   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5181   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5182   local_got_tls_masks[r_symndx] |= tls_type;
5183
5184   return local_plt + r_symndx;
5185 }
5186
5187 static bfd_boolean
5188 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5189 {
5190   struct plt_entry *ent;
5191
5192   for (ent = *plist; ent != NULL; ent = ent->next)
5193     if (ent->addend == addend)
5194       break;
5195   if (ent == NULL)
5196     {
5197       bfd_size_type amt = sizeof (*ent);
5198       ent = bfd_alloc (abfd, amt);
5199       if (ent == NULL)
5200         return FALSE;
5201       ent->next = *plist;
5202       ent->addend = addend;
5203       ent->plt.refcount = 0;
5204       *plist = ent;
5205     }
5206   ent->plt.refcount += 1;
5207   return TRUE;
5208 }
5209
5210 static bfd_boolean
5211 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5212 {
5213   return (r_type == R_PPC64_REL24
5214           || r_type == R_PPC64_REL14
5215           || r_type == R_PPC64_REL14_BRTAKEN
5216           || r_type == R_PPC64_REL14_BRNTAKEN
5217           || r_type == R_PPC64_ADDR24
5218           || r_type == R_PPC64_ADDR14
5219           || r_type == R_PPC64_ADDR14_BRTAKEN
5220           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5221 }
5222
5223 /* Look through the relocs for a section during the first phase, and
5224    calculate needed space in the global offset table, procedure
5225    linkage table, and dynamic reloc sections.  */
5226
5227 static bfd_boolean
5228 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5229                         asection *sec, const Elf_Internal_Rela *relocs)
5230 {
5231   struct ppc_link_hash_table *htab;
5232   Elf_Internal_Shdr *symtab_hdr;
5233   struct elf_link_hash_entry **sym_hashes;
5234   const Elf_Internal_Rela *rel;
5235   const Elf_Internal_Rela *rel_end;
5236   asection *sreloc;
5237   asection **opd_sym_map;
5238   struct elf_link_hash_entry *tga, *dottga;
5239
5240   if (bfd_link_relocatable (info))
5241     return TRUE;
5242
5243   /* Don't do anything special with non-loaded, non-alloced sections.
5244      In particular, any relocs in such sections should not affect GOT
5245      and PLT reference counting (ie. we don't allow them to create GOT
5246      or PLT entries), there's no possibility or desire to optimize TLS
5247      relocs, and there's not much point in propagating relocs to shared
5248      libs that the dynamic linker won't relocate.  */
5249   if ((sec->flags & SEC_ALLOC) == 0)
5250     return TRUE;
5251
5252   BFD_ASSERT (is_ppc64_elf (abfd));
5253
5254   htab = ppc_hash_table (info);
5255   if (htab == NULL)
5256     return FALSE;
5257
5258   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5259                               FALSE, FALSE, TRUE);
5260   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5261                                  FALSE, FALSE, TRUE);
5262   symtab_hdr = &elf_symtab_hdr (abfd);
5263   sym_hashes = elf_sym_hashes (abfd);
5264   sreloc = NULL;
5265   opd_sym_map = NULL;
5266   if (ppc64_elf_section_data (sec) != NULL
5267       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5268     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5269
5270   rel_end = relocs + sec->reloc_count;
5271   for (rel = relocs; rel < rel_end; rel++)
5272     {
5273       unsigned long r_symndx;
5274       struct elf_link_hash_entry *h;
5275       enum elf_ppc64_reloc_type r_type;
5276       int tls_type;
5277       struct _ppc64_elf_section_data *ppc64_sec;
5278       struct plt_entry **ifunc;
5279
5280       r_symndx = ELF64_R_SYM (rel->r_info);
5281       if (r_symndx < symtab_hdr->sh_info)
5282         h = NULL;
5283       else
5284         {
5285           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5286           h = elf_follow_link (h);
5287
5288           /* PR15323, ref flags aren't set for references in the same
5289              object.  */
5290           h->root.non_ir_ref = 1;
5291
5292           if (h == htab->elf.hgot)
5293             sec->has_toc_reloc = 1;
5294         }
5295
5296       tls_type = 0;
5297       ifunc = NULL;
5298       if (h != NULL)
5299         {
5300           if (h->type == STT_GNU_IFUNC)
5301             {
5302               h->needs_plt = 1;
5303               ifunc = &h->plt.plist;
5304             }
5305         }
5306       else
5307         {
5308           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5309                                                           abfd, r_symndx);
5310           if (isym == NULL)
5311             return FALSE;
5312
5313           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5314             {
5315               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5316                                              rel->r_addend, PLT_IFUNC);
5317               if (ifunc == NULL)
5318                 return FALSE;
5319             }
5320         }
5321       r_type = ELF64_R_TYPE (rel->r_info);
5322       if (is_branch_reloc (r_type))
5323         {
5324           if (h != NULL && (h == tga || h == dottga))
5325             {
5326               if (rel != relocs
5327                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5328                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5329                 /* We have a new-style __tls_get_addr call with a marker
5330                    reloc.  */
5331                 ;
5332               else
5333                 /* Mark this section as having an old-style call.  */
5334                 sec->has_tls_get_addr_call = 1;
5335             }
5336
5337           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5338           if (ifunc != NULL
5339               && !update_plt_info (abfd, ifunc, rel->r_addend))
5340             return FALSE;
5341         }
5342
5343       switch (r_type)
5344         {
5345         case R_PPC64_TLSGD:
5346         case R_PPC64_TLSLD:
5347           /* These special tls relocs tie a call to __tls_get_addr with
5348              its parameter symbol.  */
5349           break;
5350
5351         case R_PPC64_GOT_TLSLD16:
5352         case R_PPC64_GOT_TLSLD16_LO:
5353         case R_PPC64_GOT_TLSLD16_HI:
5354         case R_PPC64_GOT_TLSLD16_HA:
5355           tls_type = TLS_TLS | TLS_LD;
5356           goto dogottls;
5357
5358         case R_PPC64_GOT_TLSGD16:
5359         case R_PPC64_GOT_TLSGD16_LO:
5360         case R_PPC64_GOT_TLSGD16_HI:
5361         case R_PPC64_GOT_TLSGD16_HA:
5362           tls_type = TLS_TLS | TLS_GD;
5363           goto dogottls;
5364
5365         case R_PPC64_GOT_TPREL16_DS:
5366         case R_PPC64_GOT_TPREL16_LO_DS:
5367         case R_PPC64_GOT_TPREL16_HI:
5368         case R_PPC64_GOT_TPREL16_HA:
5369           if (bfd_link_pic (info))
5370             info->flags |= DF_STATIC_TLS;
5371           tls_type = TLS_TLS | TLS_TPREL;
5372           goto dogottls;
5373
5374         case R_PPC64_GOT_DTPREL16_DS:
5375         case R_PPC64_GOT_DTPREL16_LO_DS:
5376         case R_PPC64_GOT_DTPREL16_HI:
5377         case R_PPC64_GOT_DTPREL16_HA:
5378           tls_type = TLS_TLS | TLS_DTPREL;
5379         dogottls:
5380           sec->has_tls_reloc = 1;
5381           /* Fall thru */
5382
5383         case R_PPC64_GOT16:
5384         case R_PPC64_GOT16_DS:
5385         case R_PPC64_GOT16_HA:
5386         case R_PPC64_GOT16_HI:
5387         case R_PPC64_GOT16_LO:
5388         case R_PPC64_GOT16_LO_DS:
5389           /* This symbol requires a global offset table entry.  */
5390           sec->has_toc_reloc = 1;
5391           if (r_type == R_PPC64_GOT_TLSLD16
5392               || r_type == R_PPC64_GOT_TLSGD16
5393               || r_type == R_PPC64_GOT_TPREL16_DS
5394               || r_type == R_PPC64_GOT_DTPREL16_DS
5395               || r_type == R_PPC64_GOT16
5396               || r_type == R_PPC64_GOT16_DS)
5397             {
5398               htab->do_multi_toc = 1;
5399               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5400             }
5401
5402           if (ppc64_elf_tdata (abfd)->got == NULL
5403               && !create_got_section (abfd, info))
5404             return FALSE;
5405
5406           if (h != NULL)
5407             {
5408               struct ppc_link_hash_entry *eh;
5409               struct got_entry *ent;
5410
5411               eh = (struct ppc_link_hash_entry *) h;
5412               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5413                 if (ent->addend == rel->r_addend
5414                     && ent->owner == abfd
5415                     && ent->tls_type == tls_type)
5416                   break;
5417               if (ent == NULL)
5418                 {
5419                   bfd_size_type amt = sizeof (*ent);
5420                   ent = bfd_alloc (abfd, amt);
5421                   if (ent == NULL)
5422                     return FALSE;
5423                   ent->next = eh->elf.got.glist;
5424                   ent->addend = rel->r_addend;
5425                   ent->owner = abfd;
5426                   ent->tls_type = tls_type;
5427                   ent->is_indirect = FALSE;
5428                   ent->got.refcount = 0;
5429                   eh->elf.got.glist = ent;
5430                 }
5431               ent->got.refcount += 1;
5432               eh->tls_mask |= tls_type;
5433             }
5434           else
5435             /* This is a global offset table entry for a local symbol.  */
5436             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5437                                         rel->r_addend, tls_type))
5438               return FALSE;
5439
5440           /* We may also need a plt entry if the symbol turns out to be
5441              an ifunc.  */
5442           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5443             {
5444               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5445                 return FALSE;
5446             }
5447           break;
5448
5449         case R_PPC64_PLT16_HA:
5450         case R_PPC64_PLT16_HI:
5451         case R_PPC64_PLT16_LO:
5452         case R_PPC64_PLT32:
5453         case R_PPC64_PLT64:
5454           /* This symbol requires a procedure linkage table entry.  We
5455              actually build the entry in adjust_dynamic_symbol,
5456              because this might be a case of linking PIC code without
5457              linking in any dynamic objects, in which case we don't
5458              need to generate a procedure linkage table after all.  */
5459           if (h == NULL)
5460             {
5461               /* It does not make sense to have a procedure linkage
5462                  table entry for a local symbol.  */
5463               bfd_set_error (bfd_error_bad_value);
5464               return FALSE;
5465             }
5466           else
5467             {
5468               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5469                 return FALSE;
5470               h->needs_plt = 1;
5471               if (h->root.root.string[0] == '.'
5472                   && h->root.root.string[1] != '\0')
5473                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5474             }
5475           break;
5476
5477           /* The following relocations don't need to propagate the
5478              relocation if linking a shared object since they are
5479              section relative.  */
5480         case R_PPC64_SECTOFF:
5481         case R_PPC64_SECTOFF_LO:
5482         case R_PPC64_SECTOFF_HI:
5483         case R_PPC64_SECTOFF_HA:
5484         case R_PPC64_SECTOFF_DS:
5485         case R_PPC64_SECTOFF_LO_DS:
5486         case R_PPC64_DTPREL16:
5487         case R_PPC64_DTPREL16_LO:
5488         case R_PPC64_DTPREL16_HI:
5489         case R_PPC64_DTPREL16_HA:
5490         case R_PPC64_DTPREL16_DS:
5491         case R_PPC64_DTPREL16_LO_DS:
5492         case R_PPC64_DTPREL16_HIGH:
5493         case R_PPC64_DTPREL16_HIGHA:
5494         case R_PPC64_DTPREL16_HIGHER:
5495         case R_PPC64_DTPREL16_HIGHERA:
5496         case R_PPC64_DTPREL16_HIGHEST:
5497         case R_PPC64_DTPREL16_HIGHESTA:
5498           break;
5499
5500           /* Nor do these.  */
5501         case R_PPC64_REL16:
5502         case R_PPC64_REL16_LO:
5503         case R_PPC64_REL16_HI:
5504         case R_PPC64_REL16_HA:
5505           break;
5506
5507           /* Not supported as a dynamic relocation.  */
5508         case R_PPC64_ADDR64_LOCAL:
5509           if (bfd_link_pic (info))
5510             {
5511               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5512                 ppc_howto_init ();
5513               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5514                                         "in shared libraries and PIEs.\n"),
5515                                       abfd, sec, rel->r_offset,
5516                                       ppc64_elf_howto_table[r_type]->name);
5517               bfd_set_error (bfd_error_bad_value);
5518               return FALSE;
5519             }
5520           break;
5521
5522         case R_PPC64_TOC16:
5523         case R_PPC64_TOC16_DS:
5524           htab->do_multi_toc = 1;
5525           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5526         case R_PPC64_TOC16_LO:
5527         case R_PPC64_TOC16_HI:
5528         case R_PPC64_TOC16_HA:
5529         case R_PPC64_TOC16_LO_DS:
5530           sec->has_toc_reloc = 1;
5531           break;
5532
5533           /* This relocation describes the C++ object vtable hierarchy.
5534              Reconstruct it for later use during GC.  */
5535         case R_PPC64_GNU_VTINHERIT:
5536           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5537             return FALSE;
5538           break;
5539
5540           /* This relocation describes which C++ vtable entries are actually
5541              used.  Record for later use during GC.  */
5542         case R_PPC64_GNU_VTENTRY:
5543           BFD_ASSERT (h != NULL);
5544           if (h != NULL
5545               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5546             return FALSE;
5547           break;
5548
5549         case R_PPC64_REL14:
5550         case R_PPC64_REL14_BRTAKEN:
5551         case R_PPC64_REL14_BRNTAKEN:
5552           {
5553             asection *dest = NULL;
5554
5555             /* Heuristic: If jumping outside our section, chances are
5556                we are going to need a stub.  */
5557             if (h != NULL)
5558               {
5559                 /* If the sym is weak it may be overridden later, so
5560                    don't assume we know where a weak sym lives.  */
5561                 if (h->root.type == bfd_link_hash_defined)
5562                   dest = h->root.u.def.section;
5563               }
5564             else
5565               {
5566                 Elf_Internal_Sym *isym;
5567
5568                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5569                                               abfd, r_symndx);
5570                 if (isym == NULL)
5571                   return FALSE;
5572
5573                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5574               }
5575
5576             if (dest != sec)
5577               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5578           }
5579           /* Fall through.  */
5580
5581         case R_PPC64_REL24:
5582           if (h != NULL && ifunc == NULL)
5583             {
5584               /* We may need a .plt entry if the function this reloc
5585                  refers to is in a shared lib.  */
5586               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5587                 return FALSE;
5588               h->needs_plt = 1;
5589               if (h->root.root.string[0] == '.'
5590                   && h->root.root.string[1] != '\0')
5591                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5592               if (h == tga || h == dottga)
5593                 sec->has_tls_reloc = 1;
5594             }
5595           break;
5596
5597         case R_PPC64_TPREL64:
5598           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5599           if (bfd_link_pic (info))
5600             info->flags |= DF_STATIC_TLS;
5601           goto dotlstoc;
5602
5603         case R_PPC64_DTPMOD64:
5604           if (rel + 1 < rel_end
5605               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5606               && rel[1].r_offset == rel->r_offset + 8)
5607             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5608           else
5609             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5610           goto dotlstoc;
5611
5612         case R_PPC64_DTPREL64:
5613           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5614           if (rel != relocs
5615               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5616               && rel[-1].r_offset == rel->r_offset - 8)
5617             /* This is the second reloc of a dtpmod, dtprel pair.
5618                Don't mark with TLS_DTPREL.  */
5619             goto dodyn;
5620
5621         dotlstoc:
5622           sec->has_tls_reloc = 1;
5623           if (h != NULL)
5624             {
5625               struct ppc_link_hash_entry *eh;
5626               eh = (struct ppc_link_hash_entry *) h;
5627               eh->tls_mask |= tls_type;
5628             }
5629           else
5630             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5631                                         rel->r_addend, tls_type))
5632               return FALSE;
5633
5634           ppc64_sec = ppc64_elf_section_data (sec);
5635           if (ppc64_sec->sec_type != sec_toc)
5636             {
5637               bfd_size_type amt;
5638
5639               /* One extra to simplify get_tls_mask.  */
5640               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5641               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5642               if (ppc64_sec->u.toc.symndx == NULL)
5643                 return FALSE;
5644               amt = sec->size * sizeof (bfd_vma) / 8;
5645               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5646               if (ppc64_sec->u.toc.add == NULL)
5647                 return FALSE;
5648               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5649               ppc64_sec->sec_type = sec_toc;
5650             }
5651           BFD_ASSERT (rel->r_offset % 8 == 0);
5652           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5653           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5654
5655           /* Mark the second slot of a GD or LD entry.
5656              -1 to indicate GD and -2 to indicate LD.  */
5657           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5658             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5659           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5660             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5661           goto dodyn;
5662
5663         case R_PPC64_TPREL16:
5664         case R_PPC64_TPREL16_LO:
5665         case R_PPC64_TPREL16_HI:
5666         case R_PPC64_TPREL16_HA:
5667         case R_PPC64_TPREL16_DS:
5668         case R_PPC64_TPREL16_LO_DS:
5669         case R_PPC64_TPREL16_HIGH:
5670         case R_PPC64_TPREL16_HIGHA:
5671         case R_PPC64_TPREL16_HIGHER:
5672         case R_PPC64_TPREL16_HIGHERA:
5673         case R_PPC64_TPREL16_HIGHEST:
5674         case R_PPC64_TPREL16_HIGHESTA:
5675           if (bfd_link_pic (info))
5676             {
5677               info->flags |= DF_STATIC_TLS;
5678               goto dodyn;
5679             }
5680           break;
5681
5682         case R_PPC64_ADDR64:
5683           if (opd_sym_map != NULL
5684               && rel + 1 < rel_end
5685               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5686             {
5687               if (h != NULL)
5688                 {
5689                   if (h->root.root.string[0] == '.'
5690                       && h->root.root.string[1] != 0
5691                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5692                     ;
5693                   else
5694                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5695                 }
5696               else
5697                 {
5698                   asection *s;
5699                   Elf_Internal_Sym *isym;
5700
5701                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5702                                                 abfd, r_symndx);
5703                   if (isym == NULL)
5704                     return FALSE;
5705
5706                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5707                   if (s != NULL && s != sec)
5708                     opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5709                 }
5710             }
5711           /* Fall through.  */
5712
5713         case R_PPC64_ADDR16:
5714         case R_PPC64_ADDR16_DS:
5715         case R_PPC64_ADDR16_HA:
5716         case R_PPC64_ADDR16_HI:
5717         case R_PPC64_ADDR16_HIGH:
5718         case R_PPC64_ADDR16_HIGHA:
5719         case R_PPC64_ADDR16_HIGHER:
5720         case R_PPC64_ADDR16_HIGHERA:
5721         case R_PPC64_ADDR16_HIGHEST:
5722         case R_PPC64_ADDR16_HIGHESTA:
5723         case R_PPC64_ADDR16_LO:
5724         case R_PPC64_ADDR16_LO_DS:
5725           if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5726               && rel->r_addend == 0)
5727             {
5728               /* We may need a .plt entry if this reloc refers to a
5729                  function in a shared lib.  */
5730               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5731                 return FALSE;
5732               h->pointer_equality_needed = 1;
5733             }
5734           /* Fall through.  */
5735
5736         case R_PPC64_REL30:
5737         case R_PPC64_REL32:
5738         case R_PPC64_REL64:
5739         case R_PPC64_ADDR14:
5740         case R_PPC64_ADDR14_BRNTAKEN:
5741         case R_PPC64_ADDR14_BRTAKEN:
5742         case R_PPC64_ADDR24:
5743         case R_PPC64_ADDR32:
5744         case R_PPC64_UADDR16:
5745         case R_PPC64_UADDR32:
5746         case R_PPC64_UADDR64:
5747         case R_PPC64_TOC:
5748           if (h != NULL && !bfd_link_pic (info))
5749             /* We may need a copy reloc.  */
5750             h->non_got_ref = 1;
5751
5752           /* Don't propagate .opd relocs.  */
5753           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5754             break;
5755
5756           /* If we are creating a shared library, and this is a reloc
5757              against a global symbol, or a non PC relative reloc
5758              against a local symbol, then we need to copy the reloc
5759              into the shared library.  However, if we are linking with
5760              -Bsymbolic, we do not need to copy a reloc against a
5761              global symbol which is defined in an object we are
5762              including in the link (i.e., DEF_REGULAR is set).  At
5763              this point we have not seen all the input files, so it is
5764              possible that DEF_REGULAR is not set now but will be set
5765              later (it is never cleared).  In case of a weak definition,
5766              DEF_REGULAR may be cleared later by a strong definition in
5767              a shared library.  We account for that possibility below by
5768              storing information in the dyn_relocs field of the hash
5769              table entry.  A similar situation occurs when creating
5770              shared libraries and symbol visibility changes render the
5771              symbol local.
5772
5773              If on the other hand, we are creating an executable, we
5774              may need to keep relocations for symbols satisfied by a
5775              dynamic library if we manage to avoid copy relocs for the
5776              symbol.  */
5777         dodyn:
5778           if ((bfd_link_pic (info)
5779                && (must_be_dyn_reloc (info, r_type)
5780                    || (h != NULL
5781                        && (!SYMBOLIC_BIND (info, h)
5782                            || h->root.type == bfd_link_hash_defweak
5783                            || !h->def_regular))))
5784               || (ELIMINATE_COPY_RELOCS
5785                   && !bfd_link_pic (info)
5786                   && h != NULL
5787                   && (h->root.type == bfd_link_hash_defweak
5788                       || !h->def_regular))
5789               || (!bfd_link_pic (info)
5790                   && ifunc != NULL))
5791             {
5792               /* We must copy these reloc types into the output file.
5793                  Create a reloc section in dynobj and make room for
5794                  this reloc.  */
5795               if (sreloc == NULL)
5796                 {
5797                   sreloc = _bfd_elf_make_dynamic_reloc_section
5798                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5799
5800                   if (sreloc == NULL)
5801                     return FALSE;
5802                 }
5803
5804               /* If this is a global symbol, we count the number of
5805                  relocations we need for this symbol.  */
5806               if (h != NULL)
5807                 {
5808                   struct elf_dyn_relocs *p;
5809                   struct elf_dyn_relocs **head;
5810
5811                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5812                   p = *head;
5813                   if (p == NULL || p->sec != sec)
5814                     {
5815                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5816                       if (p == NULL)
5817                         return FALSE;
5818                       p->next = *head;
5819                       *head = p;
5820                       p->sec = sec;
5821                       p->count = 0;
5822                       p->pc_count = 0;
5823                     }
5824                   p->count += 1;
5825                   if (!must_be_dyn_reloc (info, r_type))
5826                     p->pc_count += 1;
5827                 }
5828               else
5829                 {
5830                   /* Track dynamic relocs needed for local syms too.
5831                      We really need local syms available to do this
5832                      easily.  Oh well.  */
5833                   struct ppc_dyn_relocs *p;
5834                   struct ppc_dyn_relocs **head;
5835                   bfd_boolean is_ifunc;
5836                   asection *s;
5837                   void *vpp;
5838                   Elf_Internal_Sym *isym;
5839
5840                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5841                                                 abfd, r_symndx);
5842                   if (isym == NULL)
5843                     return FALSE;
5844
5845                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5846                   if (s == NULL)
5847                     s = sec;
5848
5849                   vpp = &elf_section_data (s)->local_dynrel;
5850                   head = (struct ppc_dyn_relocs **) vpp;
5851                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5852                   p = *head;
5853                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5854                     p = p->next;
5855                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5856                     {
5857                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5858                       if (p == NULL)
5859                         return FALSE;
5860                       p->next = *head;
5861                       *head = p;
5862                       p->sec = sec;
5863                       p->ifunc = is_ifunc;
5864                       p->count = 0;
5865                     }
5866                   p->count += 1;
5867                 }
5868             }
5869           break;
5870
5871         default:
5872           break;
5873         }
5874     }
5875
5876   return TRUE;
5877 }
5878
5879 /* Merge backend specific data from an object file to the output
5880    object file when linking.  */
5881
5882 static bfd_boolean
5883 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5884 {
5885   unsigned long iflags, oflags;
5886
5887   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5888     return TRUE;
5889
5890   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5891     return TRUE;
5892
5893   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5894     return FALSE;
5895
5896   iflags = elf_elfheader (ibfd)->e_flags;
5897   oflags = elf_elfheader (obfd)->e_flags;
5898
5899   if (iflags & ~EF_PPC64_ABI)
5900     {
5901       (*_bfd_error_handler)
5902         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5903       bfd_set_error (bfd_error_bad_value);
5904       return FALSE;
5905     }
5906   else if (iflags != oflags && iflags != 0)
5907     {
5908       (*_bfd_error_handler)
5909         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5910          ibfd, iflags, oflags);
5911       bfd_set_error (bfd_error_bad_value);
5912       return FALSE;
5913     }
5914
5915   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5916   _bfd_elf_merge_object_attributes (ibfd, obfd);
5917
5918   return TRUE;
5919 }
5920
5921 static bfd_boolean
5922 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5923 {
5924   /* Print normal ELF private data.  */
5925   _bfd_elf_print_private_bfd_data (abfd, ptr);
5926
5927   if (elf_elfheader (abfd)->e_flags != 0)
5928     {
5929       FILE *file = ptr;
5930
5931       /* xgettext:c-format */
5932       fprintf (file, _("private flags = 0x%lx:"),
5933                elf_elfheader (abfd)->e_flags);
5934
5935       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5936         fprintf (file, _(" [abiv%ld]"),
5937                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5938       fputc ('\n', file);
5939     }
5940
5941   return TRUE;
5942 }
5943
5944 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5945    of the code entry point, and its section, which must be in the same
5946    object as OPD_SEC.  Returns (bfd_vma) -1 on error.  */
5947
5948 static bfd_vma
5949 opd_entry_value (asection *opd_sec,
5950                  bfd_vma offset,
5951                  asection **code_sec,
5952                  bfd_vma *code_off,
5953                  bfd_boolean in_code_sec)
5954 {
5955   bfd *opd_bfd = opd_sec->owner;
5956   Elf_Internal_Rela *relocs;
5957   Elf_Internal_Rela *lo, *hi, *look;
5958   bfd_vma val;
5959
5960   /* No relocs implies we are linking a --just-symbols object, or looking
5961      at a final linked executable with addr2line or somesuch.  */
5962   if (opd_sec->reloc_count == 0)
5963     {
5964       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5965
5966       if (contents == NULL)
5967         {
5968           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5969             return (bfd_vma) -1;
5970           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5971         }
5972
5973       /* PR 17512: file: 64b9dfbb.  */
5974       if (offset + 7 >= opd_sec->size || offset + 7 < offset)
5975         return (bfd_vma) -1;
5976
5977       val = bfd_get_64 (opd_bfd, contents + offset);
5978       if (code_sec != NULL)
5979         {
5980           asection *sec, *likely = NULL;
5981
5982           if (in_code_sec)
5983             {
5984               sec = *code_sec;
5985               if (sec->vma <= val
5986                   && val < sec->vma + sec->size)
5987                 likely = sec;
5988               else
5989                 val = -1;
5990             }
5991           else
5992             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5993               if (sec->vma <= val
5994                   && (sec->flags & SEC_LOAD) != 0
5995                   && (sec->flags & SEC_ALLOC) != 0)
5996                 likely = sec;
5997           if (likely != NULL)
5998             {
5999               *code_sec = likely;
6000               if (code_off != NULL)
6001                 *code_off = val - likely->vma;
6002             }
6003         }
6004       return val;
6005     }
6006
6007   BFD_ASSERT (is_ppc64_elf (opd_bfd));
6008
6009   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6010   if (relocs == NULL)
6011     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6012   /* PR 17512: file: df8e1fd6.  */
6013   if (relocs == NULL)
6014     return (bfd_vma) -1;
6015
6016   /* Go find the opd reloc at the sym address.  */
6017   lo = relocs;
6018   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6019   val = (bfd_vma) -1;
6020   while (lo < hi)
6021     {
6022       look = lo + (hi - lo) / 2;
6023       if (look->r_offset < offset)
6024         lo = look + 1;
6025       else if (look->r_offset > offset)
6026         hi = look;
6027       else
6028         {
6029           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6030
6031           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6032               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6033             {
6034               unsigned long symndx = ELF64_R_SYM (look->r_info);
6035               asection *sec = NULL;
6036
6037               if (symndx >= symtab_hdr->sh_info
6038                   && elf_sym_hashes (opd_bfd) != NULL)
6039                 {
6040                   struct elf_link_hash_entry **sym_hashes;
6041                   struct elf_link_hash_entry *rh;
6042
6043                   sym_hashes = elf_sym_hashes (opd_bfd);
6044                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6045                   if (rh != NULL)
6046                     {
6047                       rh = elf_follow_link (rh);
6048                       if (rh->root.type != bfd_link_hash_defined
6049                           && rh->root.type != bfd_link_hash_defweak)
6050                         break;
6051                       if (rh->root.u.def.section->owner == opd_bfd)
6052                         {
6053                           val = rh->root.u.def.value;
6054                           sec = rh->root.u.def.section;
6055                         }
6056                     }
6057                 }
6058
6059               if (sec == NULL)
6060                 {
6061                   Elf_Internal_Sym *sym;
6062
6063                   if (symndx < symtab_hdr->sh_info)
6064                     {
6065                       sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6066                       if (sym == NULL)
6067                         {
6068                           size_t symcnt = symtab_hdr->sh_info;
6069                           sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6070                                                       symcnt, 0,
6071                                                       NULL, NULL, NULL);
6072                           if (sym == NULL)
6073                             break;
6074                           symtab_hdr->contents = (bfd_byte *) sym;
6075                         }
6076                       sym += symndx;
6077                     }
6078                   else
6079                     {
6080                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6081                                                   1, symndx,
6082                                                   NULL, NULL, NULL);
6083                       if (sym == NULL)
6084                         break;
6085                     }
6086                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6087                   if (sec == NULL)
6088                     break;
6089                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6090                   val = sym->st_value;
6091                 }
6092
6093               val += look->r_addend;
6094               if (code_off != NULL)
6095                 *code_off = val;
6096               if (code_sec != NULL)
6097                 {
6098                   if (in_code_sec && *code_sec != sec)
6099                     return -1;
6100                   else
6101                     *code_sec = sec;
6102                 }
6103               if (sec->output_section != NULL)
6104                 val += sec->output_section->vma + sec->output_offset;
6105             }
6106           break;
6107         }
6108     }
6109
6110   return val;
6111 }
6112
6113 /* If the ELF symbol SYM might be a function in SEC, return the
6114    function size and set *CODE_OFF to the function's entry point,
6115    otherwise return zero.  */
6116
6117 static bfd_size_type
6118 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6119                               bfd_vma *code_off)
6120 {
6121   bfd_size_type size;
6122
6123   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6124                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6125     return 0;
6126
6127   size = 0;
6128   if (!(sym->flags & BSF_SYNTHETIC))
6129     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6130
6131   if (strcmp (sym->section->name, ".opd") == 0)
6132     {
6133       struct _opd_sec_data *opd = get_opd_info (sym->section);
6134       bfd_vma symval = sym->value;
6135
6136       if (opd != NULL
6137           && opd->adjust != NULL
6138           && elf_section_data (sym->section)->relocs != NULL)
6139         {
6140           /* opd_entry_value will use cached relocs that have been
6141              adjusted, but with raw symbols.  That means both local
6142              and global symbols need adjusting.  */
6143           long adjust = opd->adjust[OPD_NDX (symval)];
6144           if (adjust == -1)
6145             return 0;
6146           symval += adjust;
6147         }
6148
6149       if (opd_entry_value (sym->section, symval,
6150                            &sec, code_off, TRUE) == (bfd_vma) -1)
6151         return 0;
6152       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6153          symbol.  This size has nothing to do with the code size of the
6154          function, which is what we're supposed to return, but the
6155          code size isn't available without looking up the dot-sym.
6156          However, doing that would be a waste of time particularly
6157          since elf_find_function will look at the dot-sym anyway.
6158          Now, elf_find_function will keep the largest size of any
6159          function sym found at the code address of interest, so return
6160          1 here to avoid it incorrectly caching a larger function size
6161          for a small function.  This does mean we return the wrong
6162          size for a new-ABI function of size 24, but all that does is
6163          disable caching for such functions.  */
6164       if (size == 24)
6165         size = 1;
6166     }
6167   else
6168     {
6169       if (sym->section != sec)
6170         return 0;
6171       *code_off = sym->value;
6172     }
6173   if (size == 0)
6174     size = 1;
6175   return size;
6176 }
6177
6178 /* Return true if symbol is defined in a regular object file.  */
6179
6180 static bfd_boolean
6181 is_static_defined (struct elf_link_hash_entry *h)
6182 {
6183   return ((h->root.type == bfd_link_hash_defined
6184            || h->root.type == bfd_link_hash_defweak)
6185           && h->root.u.def.section != NULL
6186           && h->root.u.def.section->output_section != NULL);
6187 }
6188
6189 /* If FDH is a function descriptor symbol, return the associated code
6190    entry symbol if it is defined.  Return NULL otherwise.  */
6191
6192 static struct ppc_link_hash_entry *
6193 defined_code_entry (struct ppc_link_hash_entry *fdh)
6194 {
6195   if (fdh->is_func_descriptor)
6196     {
6197       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6198       if (fh->elf.root.type == bfd_link_hash_defined
6199           || fh->elf.root.type == bfd_link_hash_defweak)
6200         return fh;
6201     }
6202   return NULL;
6203 }
6204
6205 /* If FH is a function code entry symbol, return the associated
6206    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6207
6208 static struct ppc_link_hash_entry *
6209 defined_func_desc (struct ppc_link_hash_entry *fh)
6210 {
6211   if (fh->oh != NULL
6212       && fh->oh->is_func_descriptor)
6213     {
6214       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6215       if (fdh->elf.root.type == bfd_link_hash_defined
6216           || fdh->elf.root.type == bfd_link_hash_defweak)
6217         return fdh;
6218     }
6219   return NULL;
6220 }
6221
6222 /* Mark all our entry sym sections, both opd and code section.  */
6223
6224 static void
6225 ppc64_elf_gc_keep (struct bfd_link_info *info)
6226 {
6227   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6228   struct bfd_sym_chain *sym;
6229
6230   if (htab == NULL)
6231     return;
6232
6233   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6234     {
6235       struct ppc_link_hash_entry *eh, *fh;
6236       asection *sec;
6237
6238       eh = (struct ppc_link_hash_entry *)
6239         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6240       if (eh == NULL)
6241         continue;
6242       if (eh->elf.root.type != bfd_link_hash_defined
6243           && eh->elf.root.type != bfd_link_hash_defweak)
6244         continue;
6245
6246       fh = defined_code_entry (eh);
6247       if (fh != NULL)
6248         {
6249           sec = fh->elf.root.u.def.section;
6250           sec->flags |= SEC_KEEP;
6251         }
6252       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6253                && opd_entry_value (eh->elf.root.u.def.section,
6254                                    eh->elf.root.u.def.value,
6255                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6256         sec->flags |= SEC_KEEP;
6257
6258       sec = eh->elf.root.u.def.section;
6259       sec->flags |= SEC_KEEP;
6260     }
6261 }
6262
6263 /* Mark sections containing dynamically referenced symbols.  When
6264    building shared libraries, we must assume that any visible symbol is
6265    referenced.  */
6266
6267 static bfd_boolean
6268 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6269 {
6270   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6271   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6272   struct ppc_link_hash_entry *fdh;
6273   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6274
6275   /* Dynamic linking info is on the func descriptor sym.  */
6276   fdh = defined_func_desc (eh);
6277   if (fdh != NULL)
6278     eh = fdh;
6279
6280   if ((eh->elf.root.type == bfd_link_hash_defined
6281        || eh->elf.root.type == bfd_link_hash_defweak)
6282       && (eh->elf.ref_dynamic
6283           || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6284               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6285               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6286               && (!bfd_link_executable (info)
6287                   || info->export_dynamic
6288                   || (eh->elf.dynamic
6289                       && d != NULL
6290                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6291               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6292                   || !bfd_hide_sym_by_version (info->version_info,
6293                                                eh->elf.root.root.string)))))
6294     {
6295       asection *code_sec;
6296       struct ppc_link_hash_entry *fh;
6297
6298       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6299
6300       /* Function descriptor syms cause the associated
6301          function code sym section to be marked.  */
6302       fh = defined_code_entry (eh);
6303       if (fh != NULL)
6304         {
6305           code_sec = fh->elf.root.u.def.section;
6306           code_sec->flags |= SEC_KEEP;
6307         }
6308       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6309                && opd_entry_value (eh->elf.root.u.def.section,
6310                                    eh->elf.root.u.def.value,
6311                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6312         code_sec->flags |= SEC_KEEP;
6313     }
6314
6315   return TRUE;
6316 }
6317
6318 /* Return the section that should be marked against GC for a given
6319    relocation.  */
6320
6321 static asection *
6322 ppc64_elf_gc_mark_hook (asection *sec,
6323                         struct bfd_link_info *info,
6324                         Elf_Internal_Rela *rel,
6325                         struct elf_link_hash_entry *h,
6326                         Elf_Internal_Sym *sym)
6327 {
6328   asection *rsec;
6329
6330   /* Syms return NULL if we're marking .opd, so we avoid marking all
6331      function sections, as all functions are referenced in .opd.  */
6332   rsec = NULL;
6333   if (get_opd_info (sec) != NULL)
6334     return rsec;
6335
6336   if (h != NULL)
6337     {
6338       enum elf_ppc64_reloc_type r_type;
6339       struct ppc_link_hash_entry *eh, *fh, *fdh;
6340
6341       r_type = ELF64_R_TYPE (rel->r_info);
6342       switch (r_type)
6343         {
6344         case R_PPC64_GNU_VTINHERIT:
6345         case R_PPC64_GNU_VTENTRY:
6346           break;
6347
6348         default:
6349           switch (h->root.type)
6350             {
6351             case bfd_link_hash_defined:
6352             case bfd_link_hash_defweak:
6353               eh = (struct ppc_link_hash_entry *) h;
6354               fdh = defined_func_desc (eh);
6355               if (fdh != NULL)
6356                 eh = fdh;
6357
6358               /* Function descriptor syms cause the associated
6359                  function code sym section to be marked.  */
6360               fh = defined_code_entry (eh);
6361               if (fh != NULL)
6362                 {
6363                   /* They also mark their opd section.  */
6364                   eh->elf.root.u.def.section->gc_mark = 1;
6365
6366                   rsec = fh->elf.root.u.def.section;
6367                 }
6368               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6369                        && opd_entry_value (eh->elf.root.u.def.section,
6370                                            eh->elf.root.u.def.value,
6371                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6372                 eh->elf.root.u.def.section->gc_mark = 1;
6373               else
6374                 rsec = h->root.u.def.section;
6375               break;
6376
6377             case bfd_link_hash_common:
6378               rsec = h->root.u.c.p->section;
6379               break;
6380
6381             default:
6382               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6383             }
6384         }
6385     }
6386   else
6387     {
6388       struct _opd_sec_data *opd;
6389
6390       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6391       opd = get_opd_info (rsec);
6392       if (opd != NULL && opd->func_sec != NULL)
6393         {
6394           rsec->gc_mark = 1;
6395
6396           rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6397         }
6398     }
6399
6400   return rsec;
6401 }
6402
6403 /* Update the .got, .plt. and dynamic reloc reference counts for the
6404    section being removed.  */
6405
6406 static bfd_boolean
6407 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6408                          asection *sec, const Elf_Internal_Rela *relocs)
6409 {
6410   struct ppc_link_hash_table *htab;
6411   Elf_Internal_Shdr *symtab_hdr;
6412   struct elf_link_hash_entry **sym_hashes;
6413   struct got_entry **local_got_ents;
6414   const Elf_Internal_Rela *rel, *relend;
6415
6416   if (bfd_link_relocatable (info))
6417     return TRUE;
6418
6419   if ((sec->flags & SEC_ALLOC) == 0)
6420     return TRUE;
6421
6422   elf_section_data (sec)->local_dynrel = NULL;
6423
6424   htab = ppc_hash_table (info);
6425   if (htab == NULL)
6426     return FALSE;
6427
6428   symtab_hdr = &elf_symtab_hdr (abfd);
6429   sym_hashes = elf_sym_hashes (abfd);
6430   local_got_ents = elf_local_got_ents (abfd);
6431
6432   relend = relocs + sec->reloc_count;
6433   for (rel = relocs; rel < relend; rel++)
6434     {
6435       unsigned long r_symndx;
6436       enum elf_ppc64_reloc_type r_type;
6437       struct elf_link_hash_entry *h = NULL;
6438       unsigned char tls_type = 0;
6439
6440       r_symndx = ELF64_R_SYM (rel->r_info);
6441       r_type = ELF64_R_TYPE (rel->r_info);
6442       if (r_symndx >= symtab_hdr->sh_info)
6443         {
6444           struct ppc_link_hash_entry *eh;
6445           struct elf_dyn_relocs **pp;
6446           struct elf_dyn_relocs *p;
6447
6448           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6449           h = elf_follow_link (h);
6450           eh = (struct ppc_link_hash_entry *) h;
6451
6452           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6453             if (p->sec == sec)
6454               {
6455                 /* Everything must go for SEC.  */
6456                 *pp = p->next;
6457                 break;
6458               }
6459         }
6460
6461       if (is_branch_reloc (r_type))
6462         {
6463           struct plt_entry **ifunc = NULL;
6464           if (h != NULL)
6465             {
6466               if (h->type == STT_GNU_IFUNC)
6467                 ifunc = &h->plt.plist;
6468             }
6469           else if (local_got_ents != NULL)
6470             {
6471               struct plt_entry **local_plt = (struct plt_entry **)
6472                 (local_got_ents + symtab_hdr->sh_info);
6473               unsigned char *local_got_tls_masks = (unsigned char *)
6474                 (local_plt + symtab_hdr->sh_info);
6475               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6476                 ifunc = local_plt + r_symndx;
6477             }
6478           if (ifunc != NULL)
6479             {
6480               struct plt_entry *ent;
6481
6482               for (ent = *ifunc; ent != NULL; ent = ent->next)
6483                 if (ent->addend == rel->r_addend)
6484                   break;
6485               if (ent == NULL)
6486                 abort ();
6487               if (ent->plt.refcount > 0)
6488                 ent->plt.refcount -= 1;
6489               continue;
6490             }
6491         }
6492
6493       switch (r_type)
6494         {
6495         case R_PPC64_GOT_TLSLD16:
6496         case R_PPC64_GOT_TLSLD16_LO:
6497         case R_PPC64_GOT_TLSLD16_HI:
6498         case R_PPC64_GOT_TLSLD16_HA:
6499           tls_type = TLS_TLS | TLS_LD;
6500           goto dogot;
6501
6502         case R_PPC64_GOT_TLSGD16:
6503         case R_PPC64_GOT_TLSGD16_LO:
6504         case R_PPC64_GOT_TLSGD16_HI:
6505         case R_PPC64_GOT_TLSGD16_HA:
6506           tls_type = TLS_TLS | TLS_GD;
6507           goto dogot;
6508
6509         case R_PPC64_GOT_TPREL16_DS:
6510         case R_PPC64_GOT_TPREL16_LO_DS:
6511         case R_PPC64_GOT_TPREL16_HI:
6512         case R_PPC64_GOT_TPREL16_HA:
6513           tls_type = TLS_TLS | TLS_TPREL;
6514           goto dogot;
6515
6516         case R_PPC64_GOT_DTPREL16_DS:
6517         case R_PPC64_GOT_DTPREL16_LO_DS:
6518         case R_PPC64_GOT_DTPREL16_HI:
6519         case R_PPC64_GOT_DTPREL16_HA:
6520           tls_type = TLS_TLS | TLS_DTPREL;
6521           goto dogot;
6522
6523         case R_PPC64_GOT16:
6524         case R_PPC64_GOT16_DS:
6525         case R_PPC64_GOT16_HA:
6526         case R_PPC64_GOT16_HI:
6527         case R_PPC64_GOT16_LO:
6528         case R_PPC64_GOT16_LO_DS:
6529         dogot:
6530           {
6531             struct got_entry *ent;
6532
6533             if (h != NULL)
6534               ent = h->got.glist;
6535             else
6536               ent = local_got_ents[r_symndx];
6537
6538             for (; ent != NULL; ent = ent->next)
6539               if (ent->addend == rel->r_addend
6540                   && ent->owner == abfd
6541                   && ent->tls_type == tls_type)
6542                 break;
6543             if (ent == NULL)
6544               abort ();
6545             if (ent->got.refcount > 0)
6546               ent->got.refcount -= 1;
6547           }
6548           break;
6549
6550         case R_PPC64_PLT16_HA:
6551         case R_PPC64_PLT16_HI:
6552         case R_PPC64_PLT16_LO:
6553         case R_PPC64_PLT32:
6554         case R_PPC64_PLT64:
6555         case R_PPC64_REL14:
6556         case R_PPC64_REL14_BRNTAKEN:
6557         case R_PPC64_REL14_BRTAKEN:
6558         case R_PPC64_REL24:
6559           if (h != NULL)
6560             {
6561               struct plt_entry *ent;
6562
6563               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6564                 if (ent->addend == rel->r_addend)
6565                   break;
6566               if (ent != NULL && ent->plt.refcount > 0)
6567                 ent->plt.refcount -= 1;
6568             }
6569           break;
6570
6571         default:
6572           break;
6573         }
6574     }
6575   return TRUE;
6576 }
6577
6578 /* The maximum size of .sfpr.  */
6579 #define SFPR_MAX (218*4)
6580
6581 struct sfpr_def_parms
6582 {
6583   const char name[12];
6584   unsigned char lo, hi;
6585   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6586   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6587 };
6588
6589 /* Auto-generate _save*, _rest* functions in .sfpr.
6590    If STUB_SEC is non-null, define alias symbols in STUB_SEC
6591    instead.  */
6592
6593 static bfd_boolean
6594 sfpr_define (struct bfd_link_info *info,
6595              const struct sfpr_def_parms *parm,
6596              asection *stub_sec)
6597 {
6598   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6599   unsigned int i;
6600   size_t len = strlen (parm->name);
6601   bfd_boolean writing = FALSE;
6602   char sym[16];
6603
6604   if (htab == NULL)
6605     return FALSE;
6606
6607   memcpy (sym, parm->name, len);
6608   sym[len + 2] = 0;
6609
6610   for (i = parm->lo; i <= parm->hi; i++)
6611     {
6612       struct ppc_link_hash_entry *h;
6613
6614       sym[len + 0] = i / 10 + '0';
6615       sym[len + 1] = i % 10 + '0';
6616       h = (struct ppc_link_hash_entry *)
6617         elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6618       if (stub_sec != NULL)
6619         {
6620           if (h != NULL
6621               && h->elf.root.type == bfd_link_hash_defined
6622               && h->elf.root.u.def.section == htab->sfpr)
6623             {
6624               struct elf_link_hash_entry *s;
6625               char buf[32];
6626               sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6627               s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6628               if (s == NULL)
6629                 return FALSE;
6630               if (s->root.type == bfd_link_hash_new
6631                   || (s->root.type = bfd_link_hash_defined
6632                       && s->root.u.def.section == stub_sec))
6633                 {
6634                   s->root.type = bfd_link_hash_defined;
6635                   s->root.u.def.section = stub_sec;
6636                   s->root.u.def.value = (stub_sec->size
6637                                          + h->elf.root.u.def.value);
6638                   s->ref_regular = 1;
6639                   s->def_regular = 1;
6640                   s->ref_regular_nonweak = 1;
6641                   s->forced_local = 1;
6642                   s->non_elf = 0;
6643                   s->root.linker_def = 1;
6644                 }
6645             }
6646           continue;
6647         }
6648       if (h != NULL)
6649         {
6650           h->save_res = 1;
6651           if (!h->elf.def_regular)
6652             {
6653               h->elf.root.type = bfd_link_hash_defined;
6654               h->elf.root.u.def.section = htab->sfpr;
6655               h->elf.root.u.def.value = htab->sfpr->size;
6656               h->elf.type = STT_FUNC;
6657               h->elf.def_regular = 1;
6658               _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6659               writing = TRUE;
6660               if (htab->sfpr->contents == NULL)
6661                 {
6662                   htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6663                   if (htab->sfpr->contents == NULL)
6664                     return FALSE;
6665                 }
6666             }
6667         }
6668       if (writing)
6669         {
6670           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6671           if (i != parm->hi)
6672             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6673           else
6674             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6675           htab->sfpr->size = p - htab->sfpr->contents;
6676         }
6677     }
6678
6679   return TRUE;
6680 }
6681
6682 static bfd_byte *
6683 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6684 {
6685   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6686   return p + 4;
6687 }
6688
6689 static bfd_byte *
6690 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6691 {
6692   p = savegpr0 (abfd, p, r);
6693   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6694   p = p + 4;
6695   bfd_put_32 (abfd, BLR, p);
6696   return p + 4;
6697 }
6698
6699 static bfd_byte *
6700 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6701 {
6702   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6703   return p + 4;
6704 }
6705
6706 static bfd_byte *
6707 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6708 {
6709   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6710   p = p + 4;
6711   p = restgpr0 (abfd, p, r);
6712   bfd_put_32 (abfd, MTLR_R0, p);
6713   p = p + 4;
6714   if (r == 29)
6715     {
6716       p = restgpr0 (abfd, p, 30);
6717       p = restgpr0 (abfd, p, 31);
6718     }
6719   bfd_put_32 (abfd, BLR, p);
6720   return p + 4;
6721 }
6722
6723 static bfd_byte *
6724 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6725 {
6726   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6727   return p + 4;
6728 }
6729
6730 static bfd_byte *
6731 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6732 {
6733   p = savegpr1 (abfd, p, r);
6734   bfd_put_32 (abfd, BLR, p);
6735   return p + 4;
6736 }
6737
6738 static bfd_byte *
6739 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6740 {
6741   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6742   return p + 4;
6743 }
6744
6745 static bfd_byte *
6746 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6747 {
6748   p = restgpr1 (abfd, p, r);
6749   bfd_put_32 (abfd, BLR, p);
6750   return p + 4;
6751 }
6752
6753 static bfd_byte *
6754 savefpr (bfd *abfd, bfd_byte *p, int r)
6755 {
6756   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6757   return p + 4;
6758 }
6759
6760 static bfd_byte *
6761 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6762 {
6763   p = savefpr (abfd, p, r);
6764   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6765   p = p + 4;
6766   bfd_put_32 (abfd, BLR, p);
6767   return p + 4;
6768 }
6769
6770 static bfd_byte *
6771 restfpr (bfd *abfd, bfd_byte *p, int r)
6772 {
6773   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6774   return p + 4;
6775 }
6776
6777 static bfd_byte *
6778 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6779 {
6780   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6781   p = p + 4;
6782   p = restfpr (abfd, p, r);
6783   bfd_put_32 (abfd, MTLR_R0, p);
6784   p = p + 4;
6785   if (r == 29)
6786     {
6787       p = restfpr (abfd, p, 30);
6788       p = restfpr (abfd, p, 31);
6789     }
6790   bfd_put_32 (abfd, BLR, p);
6791   return p + 4;
6792 }
6793
6794 static bfd_byte *
6795 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6796 {
6797   p = savefpr (abfd, p, r);
6798   bfd_put_32 (abfd, BLR, p);
6799   return p + 4;
6800 }
6801
6802 static bfd_byte *
6803 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6804 {
6805   p = restfpr (abfd, p, r);
6806   bfd_put_32 (abfd, BLR, p);
6807   return p + 4;
6808 }
6809
6810 static bfd_byte *
6811 savevr (bfd *abfd, bfd_byte *p, int r)
6812 {
6813   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6814   p = p + 4;
6815   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6816   return p + 4;
6817 }
6818
6819 static bfd_byte *
6820 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6821 {
6822   p = savevr (abfd, p, r);
6823   bfd_put_32 (abfd, BLR, p);
6824   return p + 4;
6825 }
6826
6827 static bfd_byte *
6828 restvr (bfd *abfd, bfd_byte *p, int r)
6829 {
6830   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6831   p = p + 4;
6832   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6833   return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6838 {
6839   p = restvr (abfd, p, r);
6840   bfd_put_32 (abfd, BLR, p);
6841   return p + 4;
6842 }
6843
6844 /* Called via elf_link_hash_traverse to transfer dynamic linking
6845    information on function code symbol entries to their corresponding
6846    function descriptor symbol entries.  */
6847
6848 static bfd_boolean
6849 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6850 {
6851   struct bfd_link_info *info;
6852   struct ppc_link_hash_table *htab;
6853   struct plt_entry *ent;
6854   struct ppc_link_hash_entry *fh;
6855   struct ppc_link_hash_entry *fdh;
6856   bfd_boolean force_local;
6857
6858   fh = (struct ppc_link_hash_entry *) h;
6859   if (fh->elf.root.type == bfd_link_hash_indirect)
6860     return TRUE;
6861
6862   info = inf;
6863   htab = ppc_hash_table (info);
6864   if (htab == NULL)
6865     return FALSE;
6866
6867   /* Resolve undefined references to dot-symbols as the value
6868      in the function descriptor, if we have one in a regular object.
6869      This is to satisfy cases like ".quad .foo".  Calls to functions
6870      in dynamic objects are handled elsewhere.  */
6871   if (fh->elf.root.type == bfd_link_hash_undefweak
6872       && fh->was_undefined
6873       && (fdh = defined_func_desc (fh)) != NULL
6874       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6875       && opd_entry_value (fdh->elf.root.u.def.section,
6876                           fdh->elf.root.u.def.value,
6877                           &fh->elf.root.u.def.section,
6878                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6879     {
6880       fh->elf.root.type = fdh->elf.root.type;
6881       fh->elf.forced_local = 1;
6882       fh->elf.def_regular = fdh->elf.def_regular;
6883       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6884     }
6885
6886   /* If this is a function code symbol, transfer dynamic linking
6887      information to the function descriptor symbol.  */
6888   if (!fh->is_func)
6889     return TRUE;
6890
6891   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6892     if (ent->plt.refcount > 0)
6893       break;
6894   if (ent == NULL
6895       || fh->elf.root.root.string[0] != '.'
6896       || fh->elf.root.root.string[1] == '\0')
6897     return TRUE;
6898
6899   /* Find the corresponding function descriptor symbol.  Create it
6900      as undefined if necessary.  */
6901
6902   fdh = lookup_fdh (fh, htab);
6903   if (fdh == NULL
6904       && !bfd_link_executable (info)
6905       && (fh->elf.root.type == bfd_link_hash_undefined
6906           || fh->elf.root.type == bfd_link_hash_undefweak))
6907     {
6908       fdh = make_fdh (info, fh);
6909       if (fdh == NULL)
6910         return FALSE;
6911     }
6912
6913   /* Fake function descriptors are made undefweak.  If the function
6914      code symbol is strong undefined, make the fake sym the same.
6915      If the function code symbol is defined, then force the fake
6916      descriptor local;  We can't support overriding of symbols in a
6917      shared library on a fake descriptor.  */
6918
6919   if (fdh != NULL
6920       && fdh->fake
6921       && fdh->elf.root.type == bfd_link_hash_undefweak)
6922     {
6923       if (fh->elf.root.type == bfd_link_hash_undefined)
6924         {
6925           fdh->elf.root.type = bfd_link_hash_undefined;
6926           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6927         }
6928       else if (fh->elf.root.type == bfd_link_hash_defined
6929                || fh->elf.root.type == bfd_link_hash_defweak)
6930         {
6931           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6932         }
6933     }
6934
6935   if (fdh != NULL
6936       && !fdh->elf.forced_local
6937       && (!bfd_link_executable (info)
6938           || fdh->elf.def_dynamic
6939           || fdh->elf.ref_dynamic
6940           || (fdh->elf.root.type == bfd_link_hash_undefweak
6941               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6942     {
6943       if (fdh->elf.dynindx == -1)
6944         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6945           return FALSE;
6946       fdh->elf.ref_regular |= fh->elf.ref_regular;
6947       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6948       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6949       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6950       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6951         {
6952           move_plt_plist (fh, fdh);
6953           fdh->elf.needs_plt = 1;
6954         }
6955       fdh->is_func_descriptor = 1;
6956       fdh->oh = fh;
6957       fh->oh = fdh;
6958     }
6959
6960   /* Now that the info is on the function descriptor, clear the
6961      function code sym info.  Any function code syms for which we
6962      don't have a definition in a regular file, we force local.
6963      This prevents a shared library from exporting syms that have
6964      been imported from another library.  Function code syms that
6965      are really in the library we must leave global to prevent the
6966      linker dragging in a definition from a static library.  */
6967   force_local = (!fh->elf.def_regular
6968                  || fdh == NULL
6969                  || !fdh->elf.def_regular
6970                  || fdh->elf.forced_local);
6971   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6972
6973   return TRUE;
6974 }
6975
6976 static const struct sfpr_def_parms save_res_funcs[] =
6977   {
6978     { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6979     { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6980     { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6981     { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6982     { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6983     { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6984     { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6985     { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6986     { "._savef", 14, 31, savefpr, savefpr1_tail },
6987     { "._restf", 14, 31, restfpr, restfpr1_tail },
6988     { "_savevr_", 20, 31, savevr, savevr_tail },
6989     { "_restvr_", 20, 31, restvr, restvr_tail }
6990   };
6991
6992 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6993    this hook to a) provide some gcc support functions, and b) transfer
6994    dynamic linking information gathered so far on function code symbol
6995    entries, to their corresponding function descriptor symbol entries.  */
6996
6997 static bfd_boolean
6998 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6999                             struct bfd_link_info *info)
7000 {
7001   struct ppc_link_hash_table *htab;
7002   unsigned int i;
7003
7004   htab = ppc_hash_table (info);
7005   if (htab == NULL)
7006     return FALSE;
7007
7008   if (!bfd_link_relocatable (info)
7009       && htab->elf.hgot != NULL)
7010     {
7011       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7012       /* Make .TOC. defined so as to prevent it being made dynamic.
7013          The wrong value here is fixed later in ppc64_elf_set_toc.  */
7014       if (!htab->elf.hgot->def_regular
7015           || htab->elf.hgot->root.type != bfd_link_hash_defined)
7016         {
7017           htab->elf.hgot->root.type = bfd_link_hash_defined;
7018           htab->elf.hgot->root.u.def.value = 0;
7019           htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7020           htab->elf.hgot->def_regular = 1;
7021           htab->elf.hgot->root.linker_def = 1;
7022         }
7023       htab->elf.hgot->type = STT_OBJECT;
7024       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7025                                | STV_HIDDEN);
7026     }
7027
7028   if (htab->sfpr == NULL)
7029     /* We don't have any relocs.  */
7030     return TRUE;
7031
7032   /* Provide any missing _save* and _rest* functions.  */
7033   htab->sfpr->size = 0;
7034   if (htab->params->save_restore_funcs)
7035     for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7036       if (!sfpr_define (info, &save_res_funcs[i], NULL))
7037         return FALSE;
7038
7039   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7040
7041   if (htab->sfpr->size == 0)
7042     htab->sfpr->flags |= SEC_EXCLUDE;
7043
7044   return TRUE;
7045 }
7046
7047 /* Return true if we have dynamic relocs that apply to read-only sections.  */
7048
7049 static bfd_boolean
7050 readonly_dynrelocs (struct elf_link_hash_entry *h)
7051 {
7052   struct ppc_link_hash_entry *eh;
7053   struct elf_dyn_relocs *p;
7054
7055   eh = (struct ppc_link_hash_entry *) h;
7056   for (p = eh->dyn_relocs; p != NULL; p = p->next)
7057     {
7058       asection *s = p->sec->output_section;
7059
7060       if (s != NULL && (s->flags & SEC_READONLY) != 0)
7061         return TRUE;
7062     }
7063   return FALSE;
7064 }
7065
7066 /* Adjust a symbol defined by a dynamic object and referenced by a
7067    regular object.  The current definition is in some section of the
7068    dynamic object, but we're not including those sections.  We have to
7069    change the definition to something the rest of the link can
7070    understand.  */
7071
7072 static bfd_boolean
7073 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7074                                  struct elf_link_hash_entry *h)
7075 {
7076   struct ppc_link_hash_table *htab;
7077   asection *s;
7078
7079   htab = ppc_hash_table (info);
7080   if (htab == NULL)
7081     return FALSE;
7082
7083   /* Deal with function syms.  */
7084   if (h->type == STT_FUNC
7085       || h->type == STT_GNU_IFUNC
7086       || h->needs_plt)
7087     {
7088       /* Clear procedure linkage table information for any symbol that
7089          won't need a .plt entry.  */
7090       struct plt_entry *ent;
7091       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7092         if (ent->plt.refcount > 0)
7093           break;
7094       if (ent == NULL
7095           || (h->type != STT_GNU_IFUNC
7096               && (SYMBOL_CALLS_LOCAL (info, h)
7097                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7098                       && h->root.type == bfd_link_hash_undefweak)))
7099           || ((struct ppc_link_hash_entry *) h)->save_res)
7100         {
7101           h->plt.plist = NULL;
7102           h->needs_plt = 0;
7103           h->pointer_equality_needed = 0;
7104         }
7105       else if (abiversion (info->output_bfd) == 2)
7106         {
7107           /* Taking a function's address in a read/write section
7108              doesn't require us to define the function symbol in the
7109              executable on a global entry stub.  A dynamic reloc can
7110              be used instead.  */
7111           if (h->pointer_equality_needed
7112               && h->type != STT_GNU_IFUNC
7113               && !readonly_dynrelocs (h))
7114             {
7115               h->pointer_equality_needed = 0;
7116               h->non_got_ref = 0;
7117             }
7118
7119           /* After adjust_dynamic_symbol, non_got_ref set in the
7120              non-shared case means that we have allocated space in
7121              .dynbss for the symbol and thus dyn_relocs for this
7122              symbol should be discarded.
7123              If we get here we know we are making a PLT entry for this
7124              symbol, and in an executable we'd normally resolve
7125              relocations against this symbol to the PLT entry.  Allow
7126              dynamic relocs if the reference is weak, and the dynamic
7127              relocs will not cause text relocation.  */
7128           else if (!h->ref_regular_nonweak
7129                    && h->non_got_ref
7130                    && h->type != STT_GNU_IFUNC
7131                    && !readonly_dynrelocs (h))
7132             h->non_got_ref = 0;
7133
7134           /* If making a plt entry, then we don't need copy relocs.  */
7135           return TRUE;
7136         }
7137     }
7138   else
7139     h->plt.plist = NULL;
7140
7141   /* If this is a weak symbol, and there is a real definition, the
7142      processor independent code will have arranged for us to see the
7143      real definition first, and we can just use the same value.  */
7144   if (h->u.weakdef != NULL)
7145     {
7146       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7147                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7148       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7149       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7150       if (ELIMINATE_COPY_RELOCS)
7151         h->non_got_ref = h->u.weakdef->non_got_ref;
7152       return TRUE;
7153     }
7154
7155   /* If we are creating a shared library, we must presume that the
7156      only references to the symbol are via the global offset table.
7157      For such cases we need not do anything here; the relocations will
7158      be handled correctly by relocate_section.  */
7159   if (bfd_link_pic (info))
7160     return TRUE;
7161
7162   /* If there are no references to this symbol that do not use the
7163      GOT, we don't need to generate a copy reloc.  */
7164   if (!h->non_got_ref)
7165     return TRUE;
7166
7167   /* Don't generate a copy reloc for symbols defined in the executable.  */
7168   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7169     return TRUE;
7170
7171   /* If -z nocopyreloc was given, don't generate them either.  */
7172   if (info->nocopyreloc)
7173     {
7174       h->non_got_ref = 0;
7175       return TRUE;
7176     }
7177
7178   /* If we didn't find any dynamic relocs in read-only sections, then
7179      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7180   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7181     {
7182       h->non_got_ref = 0;
7183       return TRUE;
7184     }
7185
7186   /* Protected variables do not work with .dynbss.  The copy in
7187      .dynbss won't be used by the shared library with the protected
7188      definition for the variable.  Text relocations are preferable
7189      to an incorrect program.  */
7190   if (h->protected_def)
7191     {
7192       h->non_got_ref = 0;
7193       return TRUE;
7194     }
7195
7196   if (h->plt.plist != NULL)
7197     {
7198       /* We should never get here, but unfortunately there are versions
7199          of gcc out there that improperly (for this ABI) put initialized
7200          function pointers, vtable refs and suchlike in read-only
7201          sections.  Allow them to proceed, but warn that this might
7202          break at runtime.  */
7203       info->callbacks->einfo
7204         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7205            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7206          h->root.root.string);
7207     }
7208
7209   /* This is a reference to a symbol defined by a dynamic object which
7210      is not a function.  */
7211
7212   /* We must allocate the symbol in our .dynbss section, which will
7213      become part of the .bss section of the executable.  There will be
7214      an entry for this symbol in the .dynsym section.  The dynamic
7215      object will contain position independent code, so all references
7216      from the dynamic object to this symbol will go through the global
7217      offset table.  The dynamic linker will use the .dynsym entry to
7218      determine the address it must put in the global offset table, so
7219      both the dynamic object and the regular object will refer to the
7220      same memory location for the variable.  */
7221
7222   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7223      to copy the initial value out of the dynamic object and into the
7224      runtime process image.  We need to remember the offset into the
7225      .rela.bss section we are going to use.  */
7226   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7227     {
7228       htab->relbss->size += sizeof (Elf64_External_Rela);
7229       h->needs_copy = 1;
7230     }
7231
7232   s = htab->dynbss;
7233
7234   return _bfd_elf_adjust_dynamic_copy (info, h, s);
7235 }
7236
7237 /* If given a function descriptor symbol, hide both the function code
7238    sym and the descriptor.  */
7239 static void
7240 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7241                        struct elf_link_hash_entry *h,
7242                        bfd_boolean force_local)
7243 {
7244   struct ppc_link_hash_entry *eh;
7245   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7246
7247   eh = (struct ppc_link_hash_entry *) h;
7248   if (eh->is_func_descriptor)
7249     {
7250       struct ppc_link_hash_entry *fh = eh->oh;
7251
7252       if (fh == NULL)
7253         {
7254           const char *p, *q;
7255           struct ppc_link_hash_table *htab;
7256           char save;
7257
7258           /* We aren't supposed to use alloca in BFD because on
7259              systems which do not have alloca the version in libiberty
7260              calls xmalloc, which might cause the program to crash
7261              when it runs out of memory.  This function doesn't have a
7262              return status, so there's no way to gracefully return an
7263              error.  So cheat.  We know that string[-1] can be safely
7264              accessed;  It's either a string in an ELF string table,
7265              or allocated in an objalloc structure.  */
7266
7267           p = eh->elf.root.root.string - 1;
7268           save = *p;
7269           *(char *) p = '.';
7270           htab = ppc_hash_table (info);
7271           if (htab == NULL)
7272             return;
7273
7274           fh = (struct ppc_link_hash_entry *)
7275             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7276           *(char *) p = save;
7277
7278           /* Unfortunately, if it so happens that the string we were
7279              looking for was allocated immediately before this string,
7280              then we overwrote the string terminator.  That's the only
7281              reason the lookup should fail.  */
7282           if (fh == NULL)
7283             {
7284               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7285               while (q >= eh->elf.root.root.string && *q == *p)
7286                 --q, --p;
7287               if (q < eh->elf.root.root.string && *p == '.')
7288                 fh = (struct ppc_link_hash_entry *)
7289                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7290             }
7291           if (fh != NULL)
7292             {
7293               eh->oh = fh;
7294               fh->oh = eh;
7295             }
7296         }
7297       if (fh != NULL)
7298         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7299     }
7300 }
7301
7302 static bfd_boolean
7303 get_sym_h (struct elf_link_hash_entry **hp,
7304            Elf_Internal_Sym **symp,
7305            asection **symsecp,
7306            unsigned char **tls_maskp,
7307            Elf_Internal_Sym **locsymsp,
7308            unsigned long r_symndx,
7309            bfd *ibfd)
7310 {
7311   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7312
7313   if (r_symndx >= symtab_hdr->sh_info)
7314     {
7315       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7316       struct elf_link_hash_entry *h;
7317
7318       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7319       h = elf_follow_link (h);
7320
7321       if (hp != NULL)
7322         *hp = h;
7323
7324       if (symp != NULL)
7325         *symp = NULL;
7326
7327       if (symsecp != NULL)
7328         {
7329           asection *symsec = NULL;
7330           if (h->root.type == bfd_link_hash_defined
7331               || h->root.type == bfd_link_hash_defweak)
7332             symsec = h->root.u.def.section;
7333           *symsecp = symsec;
7334         }
7335
7336       if (tls_maskp != NULL)
7337         {
7338           struct ppc_link_hash_entry *eh;
7339
7340           eh = (struct ppc_link_hash_entry *) h;
7341           *tls_maskp = &eh->tls_mask;
7342         }
7343     }
7344   else
7345     {
7346       Elf_Internal_Sym *sym;
7347       Elf_Internal_Sym *locsyms = *locsymsp;
7348
7349       if (locsyms == NULL)
7350         {
7351           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7352           if (locsyms == NULL)
7353             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7354                                             symtab_hdr->sh_info,
7355                                             0, NULL, NULL, NULL);
7356           if (locsyms == NULL)
7357             return FALSE;
7358           *locsymsp = locsyms;
7359         }
7360       sym = locsyms + r_symndx;
7361
7362       if (hp != NULL)
7363         *hp = NULL;
7364
7365       if (symp != NULL)
7366         *symp = sym;
7367
7368       if (symsecp != NULL)
7369         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7370
7371       if (tls_maskp != NULL)
7372         {
7373           struct got_entry **lgot_ents;
7374           unsigned char *tls_mask;
7375
7376           tls_mask = NULL;
7377           lgot_ents = elf_local_got_ents (ibfd);
7378           if (lgot_ents != NULL)
7379             {
7380               struct plt_entry **local_plt = (struct plt_entry **)
7381                 (lgot_ents + symtab_hdr->sh_info);
7382               unsigned char *lgot_masks = (unsigned char *)
7383                 (local_plt + symtab_hdr->sh_info);
7384               tls_mask = &lgot_masks[r_symndx];
7385             }
7386           *tls_maskp = tls_mask;
7387         }
7388     }
7389   return TRUE;
7390 }
7391
7392 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7393    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7394    type suitable for optimization, and 1 otherwise.  */
7395
7396 static int
7397 get_tls_mask (unsigned char **tls_maskp,
7398               unsigned long *toc_symndx,
7399               bfd_vma *toc_addend,
7400               Elf_Internal_Sym **locsymsp,
7401               const Elf_Internal_Rela *rel,
7402               bfd *ibfd)
7403 {
7404   unsigned long r_symndx;
7405   int next_r;
7406   struct elf_link_hash_entry *h;
7407   Elf_Internal_Sym *sym;
7408   asection *sec;
7409   bfd_vma off;
7410
7411   r_symndx = ELF64_R_SYM (rel->r_info);
7412   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7413     return 0;
7414
7415   if ((*tls_maskp != NULL && **tls_maskp != 0)
7416       || sec == NULL
7417       || ppc64_elf_section_data (sec) == NULL
7418       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7419     return 1;
7420
7421   /* Look inside a TOC section too.  */
7422   if (h != NULL)
7423     {
7424       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7425       off = h->root.u.def.value;
7426     }
7427   else
7428     off = sym->st_value;
7429   off += rel->r_addend;
7430   BFD_ASSERT (off % 8 == 0);
7431   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7432   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7433   if (toc_symndx != NULL)
7434     *toc_symndx = r_symndx;
7435   if (toc_addend != NULL)
7436     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7437   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7438     return 0;
7439   if ((h == NULL || is_static_defined (h))
7440       && (next_r == -1 || next_r == -2))
7441     return 1 - next_r;
7442   return 1;
7443 }
7444
7445 /* Find (or create) an entry in the tocsave hash table.  */
7446
7447 static struct tocsave_entry *
7448 tocsave_find (struct ppc_link_hash_table *htab,
7449               enum insert_option insert,
7450               Elf_Internal_Sym **local_syms,
7451               const Elf_Internal_Rela *irela,
7452               bfd *ibfd)
7453 {
7454   unsigned long r_indx;
7455   struct elf_link_hash_entry *h;
7456   Elf_Internal_Sym *sym;
7457   struct tocsave_entry ent, *p;
7458   hashval_t hash;
7459   struct tocsave_entry **slot;
7460
7461   r_indx = ELF64_R_SYM (irela->r_info);
7462   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7463     return NULL;
7464   if (ent.sec == NULL || ent.sec->output_section == NULL)
7465     {
7466       (*_bfd_error_handler)
7467         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7468       return NULL;
7469     }
7470
7471   if (h != NULL)
7472     ent.offset = h->root.u.def.value;
7473   else
7474     ent.offset = sym->st_value;
7475   ent.offset += irela->r_addend;
7476
7477   hash = tocsave_htab_hash (&ent);
7478   slot = ((struct tocsave_entry **)
7479           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7480   if (slot == NULL)
7481     return NULL;
7482
7483   if (*slot == NULL)
7484     {
7485       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7486       if (p == NULL)
7487         return NULL;
7488       *p = ent;
7489       *slot = p;
7490     }
7491   return *slot;
7492 }
7493
7494 /* Adjust all global syms defined in opd sections.  In gcc generated
7495    code for the old ABI, these will already have been done.  */
7496
7497 static bfd_boolean
7498 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7499 {
7500   struct ppc_link_hash_entry *eh;
7501   asection *sym_sec;
7502   struct _opd_sec_data *opd;
7503
7504   if (h->root.type == bfd_link_hash_indirect)
7505     return TRUE;
7506
7507   if (h->root.type != bfd_link_hash_defined
7508       && h->root.type != bfd_link_hash_defweak)
7509     return TRUE;
7510
7511   eh = (struct ppc_link_hash_entry *) h;
7512   if (eh->adjust_done)
7513     return TRUE;
7514
7515   sym_sec = eh->elf.root.u.def.section;
7516   opd = get_opd_info (sym_sec);
7517   if (opd != NULL && opd->adjust != NULL)
7518     {
7519       long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7520       if (adjust == -1)
7521         {
7522           /* This entry has been deleted.  */
7523           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7524           if (dsec == NULL)
7525             {
7526               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7527                 if (discarded_section (dsec))
7528                   {
7529                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7530                     break;
7531                   }
7532             }
7533           eh->elf.root.u.def.value = 0;
7534           eh->elf.root.u.def.section = dsec;
7535         }
7536       else
7537         eh->elf.root.u.def.value += adjust;
7538       eh->adjust_done = 1;
7539     }
7540   return TRUE;
7541 }
7542
7543 /* Handles decrementing dynamic reloc counts for the reloc specified by
7544    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7545    have already been determined.  */
7546
7547 static bfd_boolean
7548 dec_dynrel_count (bfd_vma r_info,
7549                   asection *sec,
7550                   struct bfd_link_info *info,
7551                   Elf_Internal_Sym **local_syms,
7552                   struct elf_link_hash_entry *h,
7553                   Elf_Internal_Sym *sym)
7554 {
7555   enum elf_ppc64_reloc_type r_type;
7556   asection *sym_sec = NULL;
7557
7558   /* Can this reloc be dynamic?  This switch, and later tests here
7559      should be kept in sync with the code in check_relocs.  */
7560   r_type = ELF64_R_TYPE (r_info);
7561   switch (r_type)
7562     {
7563     default:
7564       return TRUE;
7565
7566     case R_PPC64_TPREL16:
7567     case R_PPC64_TPREL16_LO:
7568     case R_PPC64_TPREL16_HI:
7569     case R_PPC64_TPREL16_HA:
7570     case R_PPC64_TPREL16_DS:
7571     case R_PPC64_TPREL16_LO_DS:
7572     case R_PPC64_TPREL16_HIGH:
7573     case R_PPC64_TPREL16_HIGHA:
7574     case R_PPC64_TPREL16_HIGHER:
7575     case R_PPC64_TPREL16_HIGHERA:
7576     case R_PPC64_TPREL16_HIGHEST:
7577     case R_PPC64_TPREL16_HIGHESTA:
7578       if (!bfd_link_pic (info))
7579         return TRUE;
7580
7581     case R_PPC64_TPREL64:
7582     case R_PPC64_DTPMOD64:
7583     case R_PPC64_DTPREL64:
7584     case R_PPC64_ADDR64:
7585     case R_PPC64_REL30:
7586     case R_PPC64_REL32:
7587     case R_PPC64_REL64:
7588     case R_PPC64_ADDR14:
7589     case R_PPC64_ADDR14_BRNTAKEN:
7590     case R_PPC64_ADDR14_BRTAKEN:
7591     case R_PPC64_ADDR16:
7592     case R_PPC64_ADDR16_DS:
7593     case R_PPC64_ADDR16_HA:
7594     case R_PPC64_ADDR16_HI:
7595     case R_PPC64_ADDR16_HIGH:
7596     case R_PPC64_ADDR16_HIGHA:
7597     case R_PPC64_ADDR16_HIGHER:
7598     case R_PPC64_ADDR16_HIGHERA:
7599     case R_PPC64_ADDR16_HIGHEST:
7600     case R_PPC64_ADDR16_HIGHESTA:
7601     case R_PPC64_ADDR16_LO:
7602     case R_PPC64_ADDR16_LO_DS:
7603     case R_PPC64_ADDR24:
7604     case R_PPC64_ADDR32:
7605     case R_PPC64_UADDR16:
7606     case R_PPC64_UADDR32:
7607     case R_PPC64_UADDR64:
7608     case R_PPC64_TOC:
7609       break;
7610     }
7611
7612   if (local_syms != NULL)
7613     {
7614       unsigned long r_symndx;
7615       bfd *ibfd = sec->owner;
7616
7617       r_symndx = ELF64_R_SYM (r_info);
7618       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7619         return FALSE;
7620     }
7621
7622   if ((bfd_link_pic (info)
7623        && (must_be_dyn_reloc (info, r_type)
7624            || (h != NULL
7625                && (!SYMBOLIC_BIND (info, h)
7626                    || h->root.type == bfd_link_hash_defweak
7627                    || !h->def_regular))))
7628       || (ELIMINATE_COPY_RELOCS
7629           && !bfd_link_pic (info)
7630           && h != NULL
7631           && (h->root.type == bfd_link_hash_defweak
7632               || !h->def_regular)))
7633     ;
7634   else
7635     return TRUE;
7636
7637   if (h != NULL)
7638     {
7639       struct elf_dyn_relocs *p;
7640       struct elf_dyn_relocs **pp;
7641       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7642
7643       /* elf_gc_sweep may have already removed all dyn relocs associated
7644          with local syms for a given section.  Also, symbol flags are
7645          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7646          report a dynreloc miscount.  */
7647       if (*pp == NULL && info->gc_sections)
7648         return TRUE;
7649
7650       while ((p = *pp) != NULL)
7651         {
7652           if (p->sec == sec)
7653             {
7654               if (!must_be_dyn_reloc (info, r_type))
7655                 p->pc_count -= 1;
7656               p->count -= 1;
7657               if (p->count == 0)
7658                 *pp = p->next;
7659               return TRUE;
7660             }
7661           pp = &p->next;
7662         }
7663     }
7664   else
7665     {
7666       struct ppc_dyn_relocs *p;
7667       struct ppc_dyn_relocs **pp;
7668       void *vpp;
7669       bfd_boolean is_ifunc;
7670
7671       if (local_syms == NULL)
7672         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7673       if (sym_sec == NULL)
7674         sym_sec = sec;
7675
7676       vpp = &elf_section_data (sym_sec)->local_dynrel;
7677       pp = (struct ppc_dyn_relocs **) vpp;
7678
7679       if (*pp == NULL && info->gc_sections)
7680         return TRUE;
7681
7682       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7683       while ((p = *pp) != NULL)
7684         {
7685           if (p->sec == sec && p->ifunc == is_ifunc)
7686             {
7687               p->count -= 1;
7688               if (p->count == 0)
7689                 *pp = p->next;
7690               return TRUE;
7691             }
7692           pp = &p->next;
7693         }
7694     }
7695
7696   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7697                           sec->owner, sec);
7698   bfd_set_error (bfd_error_bad_value);
7699   return FALSE;
7700 }
7701
7702 /* Remove unused Official Procedure Descriptor entries.  Currently we
7703    only remove those associated with functions in discarded link-once
7704    sections, or weakly defined functions that have been overridden.  It
7705    would be possible to remove many more entries for statically linked
7706    applications.  */
7707
7708 bfd_boolean
7709 ppc64_elf_edit_opd (struct bfd_link_info *info)
7710 {
7711   bfd *ibfd;
7712   bfd_boolean some_edited = FALSE;
7713   asection *need_pad = NULL;
7714   struct ppc_link_hash_table *htab;
7715
7716   htab = ppc_hash_table (info);
7717   if (htab == NULL)
7718     return FALSE;
7719
7720   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7721     {
7722       asection *sec;
7723       Elf_Internal_Rela *relstart, *rel, *relend;
7724       Elf_Internal_Shdr *symtab_hdr;
7725       Elf_Internal_Sym *local_syms;
7726       struct _opd_sec_data *opd;
7727       bfd_boolean need_edit, add_aux_fields, broken;
7728       bfd_size_type cnt_16b = 0;
7729
7730       if (!is_ppc64_elf (ibfd))
7731         continue;
7732
7733       sec = bfd_get_section_by_name (ibfd, ".opd");
7734       if (sec == NULL || sec->size == 0)
7735         continue;
7736
7737       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7738         continue;
7739
7740       if (sec->output_section == bfd_abs_section_ptr)
7741         continue;
7742
7743       /* Look through the section relocs.  */
7744       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7745         continue;
7746
7747       local_syms = NULL;
7748       symtab_hdr = &elf_symtab_hdr (ibfd);
7749
7750       /* Read the relocations.  */
7751       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7752                                             info->keep_memory);
7753       if (relstart == NULL)
7754         return FALSE;
7755
7756       /* First run through the relocs to check they are sane, and to
7757          determine whether we need to edit this opd section.  */
7758       need_edit = FALSE;
7759       broken = FALSE;
7760       need_pad = sec;
7761       relend = relstart + sec->reloc_count;
7762       for (rel = relstart; rel < relend; )
7763         {
7764           enum elf_ppc64_reloc_type r_type;
7765           unsigned long r_symndx;
7766           asection *sym_sec;
7767           struct elf_link_hash_entry *h;
7768           Elf_Internal_Sym *sym;
7769           bfd_vma offset;
7770
7771           /* .opd contains an array of 16 or 24 byte entries.  We're
7772              only interested in the reloc pointing to a function entry
7773              point.  */
7774           offset = rel->r_offset;
7775           if (rel + 1 == relend
7776               || rel[1].r_offset != offset + 8)
7777             {
7778               /* If someone messes with .opd alignment then after a
7779                  "ld -r" we might have padding in the middle of .opd.
7780                  Also, there's nothing to prevent someone putting
7781                  something silly in .opd with the assembler.  No .opd
7782                  optimization for them!  */
7783             broken_opd:
7784               (*_bfd_error_handler)
7785                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7786               broken = TRUE;
7787               break;
7788             }
7789
7790           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7791               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7792             {
7793               (*_bfd_error_handler)
7794                 (_("%B: unexpected reloc type %u in .opd section"),
7795                  ibfd, r_type);
7796               broken = TRUE;
7797               break;
7798             }
7799
7800           r_symndx = ELF64_R_SYM (rel->r_info);
7801           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7802                           r_symndx, ibfd))
7803             goto error_ret;
7804
7805           if (sym_sec == NULL || sym_sec->owner == NULL)
7806             {
7807               const char *sym_name;
7808               if (h != NULL)
7809                 sym_name = h->root.root.string;
7810               else
7811                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7812                                              sym_sec);
7813
7814               (*_bfd_error_handler)
7815                 (_("%B: undefined sym `%s' in .opd section"),
7816                  ibfd, sym_name);
7817               broken = TRUE;
7818               break;
7819             }
7820
7821           /* opd entries are always for functions defined in the
7822              current input bfd.  If the symbol isn't defined in the
7823              input bfd, then we won't be using the function in this
7824              bfd;  It must be defined in a linkonce section in another
7825              bfd, or is weak.  It's also possible that we are
7826              discarding the function due to a linker script /DISCARD/,
7827              which we test for via the output_section.  */
7828           if (sym_sec->owner != ibfd
7829               || sym_sec->output_section == bfd_abs_section_ptr)
7830             need_edit = TRUE;
7831
7832           rel += 2;
7833           if (rel + 1 == relend
7834               || (rel + 2 < relend
7835                   && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7836             ++rel;
7837
7838           if (rel == relend)
7839             {
7840               if (sec->size == offset + 24)
7841                 {
7842                   need_pad = NULL;
7843                   break;
7844                 }
7845               if (sec->size == offset + 16)
7846                 {
7847                   cnt_16b++;
7848                   break;
7849                 }
7850               goto broken_opd;
7851             }
7852           else if (rel + 1 < relend
7853                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7854                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7855             {
7856               if (rel[0].r_offset == offset + 16)
7857                 cnt_16b++;
7858               else if (rel[0].r_offset != offset + 24)
7859                 goto broken_opd;
7860             }
7861           else
7862             goto broken_opd;
7863         }
7864
7865       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7866
7867       if (!broken && (need_edit || add_aux_fields))
7868         {
7869           Elf_Internal_Rela *write_rel;
7870           Elf_Internal_Shdr *rel_hdr;
7871           bfd_byte *rptr, *wptr;
7872           bfd_byte *new_contents;
7873           bfd_size_type amt;
7874
7875           new_contents = NULL;
7876           amt = OPD_NDX (sec->size) * sizeof (long);
7877           opd = &ppc64_elf_section_data (sec)->u.opd;
7878           opd->adjust = bfd_zalloc (sec->owner, amt);
7879           if (opd->adjust == NULL)
7880             return FALSE;
7881           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7882
7883           /* This seems a waste of time as input .opd sections are all
7884              zeros as generated by gcc, but I suppose there's no reason
7885              this will always be so.  We might start putting something in
7886              the third word of .opd entries.  */
7887           if ((sec->flags & SEC_IN_MEMORY) == 0)
7888             {
7889               bfd_byte *loc;
7890               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7891                 {
7892                   if (loc != NULL)
7893                     free (loc);
7894                 error_ret:
7895                   if (local_syms != NULL
7896                       && symtab_hdr->contents != (unsigned char *) local_syms)
7897                     free (local_syms);
7898                   if (elf_section_data (sec)->relocs != relstart)
7899                     free (relstart);
7900                   return FALSE;
7901                 }
7902               sec->contents = loc;
7903               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7904             }
7905
7906           elf_section_data (sec)->relocs = relstart;
7907
7908           new_contents = sec->contents;
7909           if (add_aux_fields)
7910             {
7911               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7912               if (new_contents == NULL)
7913                 return FALSE;
7914               need_pad = NULL;
7915             }
7916           wptr = new_contents;
7917           rptr = sec->contents;
7918           write_rel = relstart;
7919           for (rel = relstart; rel < relend; )
7920             {
7921               unsigned long r_symndx;
7922               asection *sym_sec;
7923               struct elf_link_hash_entry *h;
7924               struct ppc_link_hash_entry *fdh = NULL;
7925               Elf_Internal_Sym *sym;
7926               long opd_ent_size;
7927               Elf_Internal_Rela *next_rel;
7928               bfd_boolean skip;
7929
7930               r_symndx = ELF64_R_SYM (rel->r_info);
7931               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7932                               r_symndx, ibfd))
7933                 goto error_ret;
7934
7935               next_rel = rel + 2;
7936               if (next_rel + 1 == relend
7937                   || (next_rel + 2 < relend
7938                       && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7939                 ++next_rel;
7940
7941               /* See if the .opd entry is full 24 byte or
7942                  16 byte (with fd_aux entry overlapped with next
7943                  fd_func).  */
7944               opd_ent_size = 24;
7945               if (next_rel == relend)
7946                 {
7947                   if (sec->size == rel->r_offset + 16)
7948                     opd_ent_size = 16;
7949                 }
7950               else if (next_rel->r_offset == rel->r_offset + 16)
7951                 opd_ent_size = 16;
7952
7953               if (h != NULL
7954                   && h->root.root.string[0] == '.')
7955                 {
7956                   fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7957                   if (fdh != NULL
7958                       && fdh->elf.root.type != bfd_link_hash_defined
7959                       && fdh->elf.root.type != bfd_link_hash_defweak)
7960                     fdh = NULL;
7961                 }
7962
7963               skip = (sym_sec->owner != ibfd
7964                       || sym_sec->output_section == bfd_abs_section_ptr);
7965               if (skip)
7966                 {
7967                   if (fdh != NULL && sym_sec->owner == ibfd)
7968                     {
7969                       /* Arrange for the function descriptor sym
7970                          to be dropped.  */
7971                       fdh->elf.root.u.def.value = 0;
7972                       fdh->elf.root.u.def.section = sym_sec;
7973                     }
7974                   opd->adjust[OPD_NDX (rel->r_offset)] = -1;
7975
7976                   if (NO_OPD_RELOCS || bfd_link_relocatable (info))
7977                     rel = next_rel;
7978                   else
7979                     while (1)
7980                       {
7981                         if (!dec_dynrel_count (rel->r_info, sec, info,
7982                                                NULL, h, sym))
7983                           goto error_ret;
7984
7985                         if (++rel == next_rel)
7986                           break;
7987
7988                         r_symndx = ELF64_R_SYM (rel->r_info);
7989                         if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7990                                         r_symndx, ibfd))
7991                           goto error_ret;
7992                       }
7993                 }
7994               else
7995                 {
7996                   /* We'll be keeping this opd entry.  */
7997                   long adjust;
7998
7999                   if (fdh != NULL)
8000                     {
8001                       /* Redefine the function descriptor symbol to
8002                          this location in the opd section.  It is
8003                          necessary to update the value here rather
8004                          than using an array of adjustments as we do
8005                          for local symbols, because various places
8006                          in the generic ELF code use the value
8007                          stored in u.def.value.  */
8008                       fdh->elf.root.u.def.value = wptr - new_contents;
8009                       fdh->adjust_done = 1;
8010                     }
8011
8012                   /* Local syms are a bit tricky.  We could
8013                      tweak them as they can be cached, but
8014                      we'd need to look through the local syms
8015                      for the function descriptor sym which we
8016                      don't have at the moment.  So keep an
8017                      array of adjustments.  */
8018                   adjust = (wptr - new_contents) - (rptr - sec->contents);
8019                   opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8020
8021                   if (wptr != rptr)
8022                     memcpy (wptr, rptr, opd_ent_size);
8023                   wptr += opd_ent_size;
8024                   if (add_aux_fields && opd_ent_size == 16)
8025                     {
8026                       memset (wptr, '\0', 8);
8027                       wptr += 8;
8028                     }
8029
8030                   /* We need to adjust any reloc offsets to point to the
8031                      new opd entries.  */
8032                   for ( ; rel != next_rel; ++rel)
8033                     {
8034                       rel->r_offset += adjust;
8035                       if (write_rel != rel)
8036                         memcpy (write_rel, rel, sizeof (*rel));
8037                       ++write_rel;
8038                     }
8039                 }
8040
8041               rptr += opd_ent_size;
8042             }
8043
8044           sec->size = wptr - new_contents;
8045           sec->reloc_count = write_rel - relstart;
8046           if (add_aux_fields)
8047             {
8048               free (sec->contents);
8049               sec->contents = new_contents;
8050             }
8051
8052           /* Fudge the header size too, as this is used later in
8053              elf_bfd_final_link if we are emitting relocs.  */
8054           rel_hdr = _bfd_elf_single_rel_hdr (sec);
8055           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8056           some_edited = TRUE;
8057         }
8058       else if (elf_section_data (sec)->relocs != relstart)
8059         free (relstart);
8060
8061       if (local_syms != NULL
8062           && symtab_hdr->contents != (unsigned char *) local_syms)
8063         {
8064           if (!info->keep_memory)
8065             free (local_syms);
8066           else
8067             symtab_hdr->contents = (unsigned char *) local_syms;
8068         }
8069     }
8070
8071   if (some_edited)
8072     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8073
8074   /* If we are doing a final link and the last .opd entry is just 16 byte
8075      long, add a 8 byte padding after it.  */
8076   if (need_pad != NULL && !bfd_link_relocatable (info))
8077     {
8078       bfd_byte *p;
8079
8080       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8081         {
8082           BFD_ASSERT (need_pad->size > 0);
8083
8084           p = bfd_malloc (need_pad->size + 8);
8085           if (p == NULL)
8086             return FALSE;
8087
8088           if (! bfd_get_section_contents (need_pad->owner, need_pad,
8089                                           p, 0, need_pad->size))
8090             return FALSE;
8091
8092           need_pad->contents = p;
8093           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8094         }
8095       else
8096         {
8097           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8098           if (p == NULL)
8099             return FALSE;
8100
8101           need_pad->contents = p;
8102         }
8103
8104       memset (need_pad->contents + need_pad->size, 0, 8);
8105       need_pad->size += 8;
8106     }
8107
8108   return TRUE;
8109 }
8110
8111 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
8112
8113 asection *
8114 ppc64_elf_tls_setup (struct bfd_link_info *info)
8115 {
8116   struct ppc_link_hash_table *htab;
8117
8118   htab = ppc_hash_table (info);
8119   if (htab == NULL)
8120     return NULL;
8121
8122   if (abiversion (info->output_bfd) == 1)
8123     htab->opd_abi = 1;
8124
8125   if (htab->params->no_multi_toc)
8126     htab->do_multi_toc = 0;
8127   else if (!htab->do_multi_toc)
8128     htab->params->no_multi_toc = 1;
8129
8130   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8131                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8132                                               FALSE, FALSE, TRUE));
8133   /* Move dynamic linking info to the function descriptor sym.  */
8134   if (htab->tls_get_addr != NULL)
8135     func_desc_adjust (&htab->tls_get_addr->elf, info);
8136   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8137                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8138                                                  FALSE, FALSE, TRUE));
8139   if (htab->params->tls_get_addr_opt)
8140     {
8141       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8142
8143       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8144                                   FALSE, FALSE, TRUE);
8145       if (opt != NULL)
8146         func_desc_adjust (opt, info);
8147       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8148                                      FALSE, FALSE, TRUE);
8149       if (opt_fd != NULL
8150           && (opt_fd->root.type == bfd_link_hash_defined
8151               || opt_fd->root.type == bfd_link_hash_defweak))
8152         {
8153           /* If glibc supports an optimized __tls_get_addr call stub,
8154              signalled by the presence of __tls_get_addr_opt, and we'll
8155              be calling __tls_get_addr via a plt call stub, then
8156              make __tls_get_addr point to __tls_get_addr_opt.  */
8157           tga_fd = &htab->tls_get_addr_fd->elf;
8158           if (htab->elf.dynamic_sections_created
8159               && tga_fd != NULL
8160               && (tga_fd->type == STT_FUNC
8161                   || tga_fd->needs_plt)
8162               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8163                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8164                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8165             {
8166               struct plt_entry *ent;
8167
8168               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8169                 if (ent->plt.refcount > 0)
8170                   break;
8171               if (ent != NULL)
8172                 {
8173                   tga_fd->root.type = bfd_link_hash_indirect;
8174                   tga_fd->root.u.i.link = &opt_fd->root;
8175                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8176                   if (opt_fd->dynindx != -1)
8177                     {
8178                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8179                       opt_fd->dynindx = -1;
8180                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8181                                               opt_fd->dynstr_index);
8182                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8183                         return NULL;
8184                     }
8185                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8186                   tga = &htab->tls_get_addr->elf;
8187                   if (opt != NULL && tga != NULL)
8188                     {
8189                       tga->root.type = bfd_link_hash_indirect;
8190                       tga->root.u.i.link = &opt->root;
8191                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8192                       _bfd_elf_link_hash_hide_symbol (info, opt,
8193                                                       tga->forced_local);
8194                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8195                     }
8196                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8197                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8198                   if (htab->tls_get_addr != NULL)
8199                     {
8200                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8201                       htab->tls_get_addr->is_func = 1;
8202                     }
8203                 }
8204             }
8205         }
8206       else if (htab->params->tls_get_addr_opt < 0)
8207         htab->params->tls_get_addr_opt = 0;
8208     }
8209   return _bfd_elf_tls_setup (info->output_bfd, info);
8210 }
8211
8212 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8213    HASH1 or HASH2.  */
8214
8215 static bfd_boolean
8216 branch_reloc_hash_match (const bfd *ibfd,
8217                          const Elf_Internal_Rela *rel,
8218                          const struct ppc_link_hash_entry *hash1,
8219                          const struct ppc_link_hash_entry *hash2)
8220 {
8221   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8222   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8223   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8224
8225   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8226     {
8227       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8228       struct elf_link_hash_entry *h;
8229
8230       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8231       h = elf_follow_link (h);
8232       if (h == &hash1->elf || h == &hash2->elf)
8233         return TRUE;
8234     }
8235   return FALSE;
8236 }
8237
8238 /* Run through all the TLS relocs looking for optimization
8239    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8240    a preliminary section layout so that we know the TLS segment
8241    offsets.  We can't optimize earlier because some optimizations need
8242    to know the tp offset, and we need to optimize before allocating
8243    dynamic relocations.  */
8244
8245 bfd_boolean
8246 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8247 {
8248   bfd *ibfd;
8249   asection *sec;
8250   struct ppc_link_hash_table *htab;
8251   unsigned char *toc_ref;
8252   int pass;
8253
8254   if (!bfd_link_executable (info))
8255     return TRUE;
8256
8257   htab = ppc_hash_table (info);
8258   if (htab == NULL)
8259     return FALSE;
8260
8261   /* Make two passes over the relocs.  On the first pass, mark toc
8262      entries involved with tls relocs, and check that tls relocs
8263      involved in setting up a tls_get_addr call are indeed followed by
8264      such a call.  If they are not, we can't do any tls optimization.
8265      On the second pass twiddle tls_mask flags to notify
8266      relocate_section that optimization can be done, and adjust got
8267      and plt refcounts.  */
8268   toc_ref = NULL;
8269   for (pass = 0; pass < 2; ++pass)
8270     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8271       {
8272         Elf_Internal_Sym *locsyms = NULL;
8273         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8274
8275         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8276           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8277             {
8278               Elf_Internal_Rela *relstart, *rel, *relend;
8279               bfd_boolean found_tls_get_addr_arg = 0;
8280
8281               /* Read the relocations.  */
8282               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8283                                                     info->keep_memory);
8284               if (relstart == NULL)
8285                 {
8286                   free (toc_ref);
8287                   return FALSE;
8288                 }
8289
8290               relend = relstart + sec->reloc_count;
8291               for (rel = relstart; rel < relend; rel++)
8292                 {
8293                   enum elf_ppc64_reloc_type r_type;
8294                   unsigned long r_symndx;
8295                   struct elf_link_hash_entry *h;
8296                   Elf_Internal_Sym *sym;
8297                   asection *sym_sec;
8298                   unsigned char *tls_mask;
8299                   unsigned char tls_set, tls_clear, tls_type = 0;
8300                   bfd_vma value;
8301                   bfd_boolean ok_tprel, is_local;
8302                   long toc_ref_index = 0;
8303                   int expecting_tls_get_addr = 0;
8304                   bfd_boolean ret = FALSE;
8305
8306                   r_symndx = ELF64_R_SYM (rel->r_info);
8307                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8308                                   r_symndx, ibfd))
8309                     {
8310                     err_free_rel:
8311                       if (elf_section_data (sec)->relocs != relstart)
8312                         free (relstart);
8313                       if (toc_ref != NULL)
8314                         free (toc_ref);
8315                       if (locsyms != NULL
8316                           && (elf_symtab_hdr (ibfd).contents
8317                               != (unsigned char *) locsyms))
8318                         free (locsyms);
8319                       return ret;
8320                     }
8321
8322                   if (h != NULL)
8323                     {
8324                       if (h->root.type == bfd_link_hash_defined
8325                           || h->root.type == bfd_link_hash_defweak)
8326                         value = h->root.u.def.value;
8327                       else if (h->root.type == bfd_link_hash_undefweak)
8328                         value = 0;
8329                       else
8330                         {
8331                           found_tls_get_addr_arg = 0;
8332                           continue;
8333                         }
8334                     }
8335                   else
8336                     /* Symbols referenced by TLS relocs must be of type
8337                        STT_TLS.  So no need for .opd local sym adjust.  */
8338                     value = sym->st_value;
8339
8340                   ok_tprel = FALSE;
8341                   is_local = FALSE;
8342                   if (h == NULL
8343                       || !h->def_dynamic)
8344                     {
8345                       is_local = TRUE;
8346                       if (h != NULL
8347                           && h->root.type == bfd_link_hash_undefweak)
8348                         ok_tprel = TRUE;
8349                       else
8350                         {
8351                           value += sym_sec->output_offset;
8352                           value += sym_sec->output_section->vma;
8353                           value -= htab->elf.tls_sec->vma;
8354                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8355                                       < (bfd_vma) 1 << 32);
8356                         }
8357                     }
8358
8359                   r_type = ELF64_R_TYPE (rel->r_info);
8360                   /* If this section has old-style __tls_get_addr calls
8361                      without marker relocs, then check that each
8362                      __tls_get_addr call reloc is preceded by a reloc
8363                      that conceivably belongs to the __tls_get_addr arg
8364                      setup insn.  If we don't find matching arg setup
8365                      relocs, don't do any tls optimization.  */
8366                   if (pass == 0
8367                       && sec->has_tls_get_addr_call
8368                       && h != NULL
8369                       && (h == &htab->tls_get_addr->elf
8370                           || h == &htab->tls_get_addr_fd->elf)
8371                       && !found_tls_get_addr_arg
8372                       && is_branch_reloc (r_type))
8373                     {
8374                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8375                                                 "TLS optimization disabled\n"),
8376                                               ibfd, sec, rel->r_offset);
8377                       ret = TRUE;
8378                       goto err_free_rel;
8379                     }
8380
8381                   found_tls_get_addr_arg = 0;
8382                   switch (r_type)
8383                     {
8384                     case R_PPC64_GOT_TLSLD16:
8385                     case R_PPC64_GOT_TLSLD16_LO:
8386                       expecting_tls_get_addr = 1;
8387                       found_tls_get_addr_arg = 1;
8388                       /* Fall thru */
8389
8390                     case R_PPC64_GOT_TLSLD16_HI:
8391                     case R_PPC64_GOT_TLSLD16_HA:
8392                       /* These relocs should never be against a symbol
8393                          defined in a shared lib.  Leave them alone if
8394                          that turns out to be the case.  */
8395                       if (!is_local)
8396                         continue;
8397
8398                       /* LD -> LE */
8399                       tls_set = 0;
8400                       tls_clear = TLS_LD;
8401                       tls_type = TLS_TLS | TLS_LD;
8402                       break;
8403
8404                     case R_PPC64_GOT_TLSGD16:
8405                     case R_PPC64_GOT_TLSGD16_LO:
8406                       expecting_tls_get_addr = 1;
8407                       found_tls_get_addr_arg = 1;
8408                       /* Fall thru */
8409
8410                     case R_PPC64_GOT_TLSGD16_HI:
8411                     case R_PPC64_GOT_TLSGD16_HA:
8412                       if (ok_tprel)
8413                         /* GD -> LE */
8414                         tls_set = 0;
8415                       else
8416                         /* GD -> IE */
8417                         tls_set = TLS_TLS | TLS_TPRELGD;
8418                       tls_clear = TLS_GD;
8419                       tls_type = TLS_TLS | TLS_GD;
8420                       break;
8421
8422                     case R_PPC64_GOT_TPREL16_DS:
8423                     case R_PPC64_GOT_TPREL16_LO_DS:
8424                     case R_PPC64_GOT_TPREL16_HI:
8425                     case R_PPC64_GOT_TPREL16_HA:
8426                       if (ok_tprel)
8427                         {
8428                           /* IE -> LE */
8429                           tls_set = 0;
8430                           tls_clear = TLS_TPREL;
8431                           tls_type = TLS_TLS | TLS_TPREL;
8432                           break;
8433                         }
8434                       continue;
8435
8436                     case R_PPC64_TLSGD:
8437                     case R_PPC64_TLSLD:
8438                       found_tls_get_addr_arg = 1;
8439                       /* Fall thru */
8440
8441                     case R_PPC64_TLS:
8442                     case R_PPC64_TOC16:
8443                     case R_PPC64_TOC16_LO:
8444                       if (sym_sec == NULL || sym_sec != toc)
8445                         continue;
8446
8447                       /* Mark this toc entry as referenced by a TLS
8448                          code sequence.  We can do that now in the
8449                          case of R_PPC64_TLS, and after checking for
8450                          tls_get_addr for the TOC16 relocs.  */
8451                       if (toc_ref == NULL)
8452                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8453                       if (toc_ref == NULL)
8454                         goto err_free_rel;
8455
8456                       if (h != NULL)
8457                         value = h->root.u.def.value;
8458                       else
8459                         value = sym->st_value;
8460                       value += rel->r_addend;
8461                       if (value % 8 != 0)
8462                         continue;
8463                       BFD_ASSERT (value < toc->size
8464                                   && toc->output_offset % 8 == 0);
8465                       toc_ref_index = (value + toc->output_offset) / 8;
8466                       if (r_type == R_PPC64_TLS
8467                           || r_type == R_PPC64_TLSGD
8468                           || r_type == R_PPC64_TLSLD)
8469                         {
8470                           toc_ref[toc_ref_index] = 1;
8471                           continue;
8472                         }
8473
8474                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8475                         continue;
8476
8477                       tls_set = 0;
8478                       tls_clear = 0;
8479                       expecting_tls_get_addr = 2;
8480                       break;
8481
8482                     case R_PPC64_TPREL64:
8483                       if (pass == 0
8484                           || sec != toc
8485                           || toc_ref == NULL
8486                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8487                         continue;
8488                       if (ok_tprel)
8489                         {
8490                           /* IE -> LE */
8491                           tls_set = TLS_EXPLICIT;
8492                           tls_clear = TLS_TPREL;
8493                           break;
8494                         }
8495                       continue;
8496
8497                     case R_PPC64_DTPMOD64:
8498                       if (pass == 0
8499                           || sec != toc
8500                           || toc_ref == NULL
8501                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8502                         continue;
8503                       if (rel + 1 < relend
8504                           && (rel[1].r_info
8505                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8506                           && rel[1].r_offset == rel->r_offset + 8)
8507                         {
8508                           if (ok_tprel)
8509                             /* GD -> LE */
8510                             tls_set = TLS_EXPLICIT | TLS_GD;
8511                           else
8512                             /* GD -> IE */
8513                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8514                           tls_clear = TLS_GD;
8515                         }
8516                       else
8517                         {
8518                           if (!is_local)
8519                             continue;
8520
8521                           /* LD -> LE */
8522                           tls_set = TLS_EXPLICIT;
8523                           tls_clear = TLS_LD;
8524                         }
8525                       break;
8526
8527                     default:
8528                       continue;
8529                     }
8530
8531                   if (pass == 0)
8532                     {
8533                       if (!expecting_tls_get_addr
8534                           || !sec->has_tls_get_addr_call)
8535                         continue;
8536
8537                       if (rel + 1 < relend
8538                           && branch_reloc_hash_match (ibfd, rel + 1,
8539                                                       htab->tls_get_addr,
8540                                                       htab->tls_get_addr_fd))
8541                         {
8542                           if (expecting_tls_get_addr == 2)
8543                             {
8544                               /* Check for toc tls entries.  */
8545                               unsigned char *toc_tls;
8546                               int retval;
8547
8548                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8549                                                      &locsyms,
8550                                                      rel, ibfd);
8551                               if (retval == 0)
8552                                 goto err_free_rel;
8553                               if (toc_tls != NULL)
8554                                 {
8555                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8556                                     found_tls_get_addr_arg = 1;
8557                                   if (retval > 1)
8558                                     toc_ref[toc_ref_index] = 1;
8559                                 }
8560                             }
8561                           continue;
8562                         }
8563
8564                       if (expecting_tls_get_addr != 1)
8565                         continue;
8566
8567                       /* Uh oh, we didn't find the expected call.  We
8568                          could just mark this symbol to exclude it
8569                          from tls optimization but it's safer to skip
8570                          the entire optimization.  */
8571                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8572                                                 "TLS optimization disabled\n"),
8573                                               ibfd, sec, rel->r_offset);
8574                       ret = TRUE;
8575                       goto err_free_rel;
8576                     }
8577
8578                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8579                     {
8580                       struct plt_entry *ent;
8581                       for (ent = htab->tls_get_addr->elf.plt.plist;
8582                            ent != NULL;
8583                            ent = ent->next)
8584                         if (ent->addend == 0)
8585                           {
8586                             if (ent->plt.refcount > 0)
8587                               {
8588                                 ent->plt.refcount -= 1;
8589                                 expecting_tls_get_addr = 0;
8590                               }
8591                             break;
8592                           }
8593                     }
8594
8595                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8596                     {
8597                       struct plt_entry *ent;
8598                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8599                            ent != NULL;
8600                            ent = ent->next)
8601                         if (ent->addend == 0)
8602                           {
8603                             if (ent->plt.refcount > 0)
8604                               ent->plt.refcount -= 1;
8605                             break;
8606                           }
8607                     }
8608
8609                   if (tls_clear == 0)
8610                     continue;
8611
8612                   if ((tls_set & TLS_EXPLICIT) == 0)
8613                     {
8614                       struct got_entry *ent;
8615
8616                       /* Adjust got entry for this reloc.  */
8617                       if (h != NULL)
8618                         ent = h->got.glist;
8619                       else
8620                         ent = elf_local_got_ents (ibfd)[r_symndx];
8621
8622                       for (; ent != NULL; ent = ent->next)
8623                         if (ent->addend == rel->r_addend
8624                             && ent->owner == ibfd
8625                             && ent->tls_type == tls_type)
8626                           break;
8627                       if (ent == NULL)
8628                         abort ();
8629
8630                       if (tls_set == 0)
8631                         {
8632                           /* We managed to get rid of a got entry.  */
8633                           if (ent->got.refcount > 0)
8634                             ent->got.refcount -= 1;
8635                         }
8636                     }
8637                   else
8638                     {
8639                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8640                          we'll lose one or two dyn relocs.  */
8641                       if (!dec_dynrel_count (rel->r_info, sec, info,
8642                                              NULL, h, sym))
8643                         return FALSE;
8644
8645                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8646                         {
8647                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8648                                                  NULL, h, sym))
8649                             return FALSE;
8650                         }
8651                     }
8652
8653                   *tls_mask |= tls_set;
8654                   *tls_mask &= ~tls_clear;
8655                 }
8656
8657               if (elf_section_data (sec)->relocs != relstart)
8658                 free (relstart);
8659             }
8660
8661         if (locsyms != NULL
8662             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8663           {
8664             if (!info->keep_memory)
8665               free (locsyms);
8666             else
8667               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8668           }
8669       }
8670
8671   if (toc_ref != NULL)
8672     free (toc_ref);
8673   return TRUE;
8674 }
8675
8676 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8677    the values of any global symbols in a toc section that has been
8678    edited.  Globals in toc sections should be a rarity, so this function
8679    sets a flag if any are found in toc sections other than the one just
8680    edited, so that futher hash table traversals can be avoided.  */
8681
8682 struct adjust_toc_info
8683 {
8684   asection *toc;
8685   unsigned long *skip;
8686   bfd_boolean global_toc_syms;
8687 };
8688
8689 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8690
8691 static bfd_boolean
8692 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8693 {
8694   struct ppc_link_hash_entry *eh;
8695   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8696   unsigned long i;
8697
8698   if (h->root.type != bfd_link_hash_defined
8699       && h->root.type != bfd_link_hash_defweak)
8700     return TRUE;
8701
8702   eh = (struct ppc_link_hash_entry *) h;
8703   if (eh->adjust_done)
8704     return TRUE;
8705
8706   if (eh->elf.root.u.def.section == toc_inf->toc)
8707     {
8708       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8709         i = toc_inf->toc->rawsize >> 3;
8710       else
8711         i = eh->elf.root.u.def.value >> 3;
8712
8713       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8714         {
8715           (*_bfd_error_handler)
8716             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8717           do
8718             ++i;
8719           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8720           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8721         }
8722
8723       eh->elf.root.u.def.value -= toc_inf->skip[i];
8724       eh->adjust_done = 1;
8725     }
8726   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8727     toc_inf->global_toc_syms = TRUE;
8728
8729   return TRUE;
8730 }
8731
8732 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8733
8734 static bfd_boolean
8735 ok_lo_toc_insn (unsigned int insn)
8736 {
8737   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8738           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8739           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8740           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8741           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8742           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8743           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8744           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8745           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8746           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8747           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8748           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8749           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8750           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8751           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8752               && (insn & 3) != 1)
8753           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8754               && ((insn & 3) == 0 || (insn & 3) == 3))
8755           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8756 }
8757
8758 /* Examine all relocs referencing .toc sections in order to remove
8759    unused .toc entries.  */
8760
8761 bfd_boolean
8762 ppc64_elf_edit_toc (struct bfd_link_info *info)
8763 {
8764   bfd *ibfd;
8765   struct adjust_toc_info toc_inf;
8766   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8767
8768   htab->do_toc_opt = 1;
8769   toc_inf.global_toc_syms = TRUE;
8770   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8771     {
8772       asection *toc, *sec;
8773       Elf_Internal_Shdr *symtab_hdr;
8774       Elf_Internal_Sym *local_syms;
8775       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8776       unsigned long *skip, *drop;
8777       unsigned char *used;
8778       unsigned char *keep, last, some_unused;
8779
8780       if (!is_ppc64_elf (ibfd))
8781         continue;
8782
8783       toc = bfd_get_section_by_name (ibfd, ".toc");
8784       if (toc == NULL
8785           || toc->size == 0
8786           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8787           || discarded_section (toc))
8788         continue;
8789
8790       toc_relocs = NULL;
8791       local_syms = NULL;
8792       symtab_hdr = &elf_symtab_hdr (ibfd);
8793
8794       /* Look at sections dropped from the final link.  */
8795       skip = NULL;
8796       relstart = NULL;
8797       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8798         {
8799           if (sec->reloc_count == 0
8800               || !discarded_section (sec)
8801               || get_opd_info (sec)
8802               || (sec->flags & SEC_ALLOC) == 0
8803               || (sec->flags & SEC_DEBUGGING) != 0)
8804             continue;
8805
8806           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8807           if (relstart == NULL)
8808             goto error_ret;
8809
8810           /* Run through the relocs to see which toc entries might be
8811              unused.  */
8812           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8813             {
8814               enum elf_ppc64_reloc_type r_type;
8815               unsigned long r_symndx;
8816               asection *sym_sec;
8817               struct elf_link_hash_entry *h;
8818               Elf_Internal_Sym *sym;
8819               bfd_vma val;
8820
8821               r_type = ELF64_R_TYPE (rel->r_info);
8822               switch (r_type)
8823                 {
8824                 default:
8825                   continue;
8826
8827                 case R_PPC64_TOC16:
8828                 case R_PPC64_TOC16_LO:
8829                 case R_PPC64_TOC16_HI:
8830                 case R_PPC64_TOC16_HA:
8831                 case R_PPC64_TOC16_DS:
8832                 case R_PPC64_TOC16_LO_DS:
8833                   break;
8834                 }
8835
8836               r_symndx = ELF64_R_SYM (rel->r_info);
8837               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8838                               r_symndx, ibfd))
8839                 goto error_ret;
8840
8841               if (sym_sec != toc)
8842                 continue;
8843
8844               if (h != NULL)
8845                 val = h->root.u.def.value;
8846               else
8847                 val = sym->st_value;
8848               val += rel->r_addend;
8849
8850               if (val >= toc->size)
8851                 continue;
8852
8853               /* Anything in the toc ought to be aligned to 8 bytes.
8854                  If not, don't mark as unused.  */
8855               if (val & 7)
8856                 continue;
8857
8858               if (skip == NULL)
8859                 {
8860                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8861                   if (skip == NULL)
8862                     goto error_ret;
8863                 }
8864
8865               skip[val >> 3] = ref_from_discarded;
8866             }
8867
8868           if (elf_section_data (sec)->relocs != relstart)
8869             free (relstart);
8870         }
8871
8872       /* For largetoc loads of address constants, we can convert
8873          .  addis rx,2,addr@got@ha
8874          .  ld ry,addr@got@l(rx)
8875          to
8876          .  addis rx,2,addr@toc@ha
8877          .  addi ry,rx,addr@toc@l
8878          when addr is within 2G of the toc pointer.  This then means
8879          that the word storing "addr" in the toc is no longer needed.  */
8880
8881       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8882           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8883           && toc->reloc_count != 0)
8884         {
8885           /* Read toc relocs.  */
8886           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8887                                                   info->keep_memory);
8888           if (toc_relocs == NULL)
8889             goto error_ret;
8890
8891           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8892             {
8893               enum elf_ppc64_reloc_type r_type;
8894               unsigned long r_symndx;
8895               asection *sym_sec;
8896               struct elf_link_hash_entry *h;
8897               Elf_Internal_Sym *sym;
8898               bfd_vma val, addr;
8899
8900               r_type = ELF64_R_TYPE (rel->r_info);
8901               if (r_type != R_PPC64_ADDR64)
8902                 continue;
8903
8904               r_symndx = ELF64_R_SYM (rel->r_info);
8905               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8906                               r_symndx, ibfd))
8907                 goto error_ret;
8908
8909               if (sym_sec == NULL
8910                   || discarded_section (sym_sec))
8911                 continue;
8912
8913               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8914                 continue;
8915
8916               if (h != NULL)
8917                 {
8918                   if (h->type == STT_GNU_IFUNC)
8919                     continue;
8920                   val = h->root.u.def.value;
8921                 }
8922               else
8923                 {
8924                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8925                     continue;
8926                   val = sym->st_value;
8927                 }
8928               val += rel->r_addend;
8929               val += sym_sec->output_section->vma + sym_sec->output_offset;
8930
8931               /* We don't yet know the exact toc pointer value, but we
8932                  know it will be somewhere in the toc section.  Don't
8933                  optimize if the difference from any possible toc
8934                  pointer is outside [ff..f80008000, 7fff7fff].  */
8935               addr = toc->output_section->vma + TOC_BASE_OFF;
8936               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8937                 continue;
8938
8939               addr = toc->output_section->vma + toc->output_section->rawsize;
8940               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8941                 continue;
8942
8943               if (skip == NULL)
8944                 {
8945                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8946                   if (skip == NULL)
8947                     goto error_ret;
8948                 }
8949
8950               skip[rel->r_offset >> 3]
8951                 |= can_optimize | ((rel - toc_relocs) << 2);
8952             }
8953         }
8954
8955       if (skip == NULL)
8956         continue;
8957
8958       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8959       if (used == NULL)
8960         {
8961         error_ret:
8962           if (local_syms != NULL
8963               && symtab_hdr->contents != (unsigned char *) local_syms)
8964             free (local_syms);
8965           if (sec != NULL
8966               && relstart != NULL
8967               && elf_section_data (sec)->relocs != relstart)
8968             free (relstart);
8969           if (toc_relocs != NULL
8970               && elf_section_data (toc)->relocs != toc_relocs)
8971             free (toc_relocs);
8972           if (skip != NULL)
8973             free (skip);
8974           return FALSE;
8975         }
8976
8977       /* Now check all kept sections that might reference the toc.
8978          Check the toc itself last.  */
8979       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8980                   : ibfd->sections);
8981            sec != NULL;
8982            sec = (sec == toc ? NULL
8983                   : sec->next == NULL ? toc
8984                   : sec->next == toc && toc->next ? toc->next
8985                   : sec->next))
8986         {
8987           int repeat;
8988
8989           if (sec->reloc_count == 0
8990               || discarded_section (sec)
8991               || get_opd_info (sec)
8992               || (sec->flags & SEC_ALLOC) == 0
8993               || (sec->flags & SEC_DEBUGGING) != 0)
8994             continue;
8995
8996           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8997                                                 info->keep_memory);
8998           if (relstart == NULL)
8999             {
9000               free (used);
9001               goto error_ret;
9002             }
9003
9004           /* Mark toc entries referenced as used.  */
9005           do
9006             {
9007               repeat = 0;
9008               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9009                 {
9010                   enum elf_ppc64_reloc_type r_type;
9011                   unsigned long r_symndx;
9012                   asection *sym_sec;
9013                   struct elf_link_hash_entry *h;
9014                   Elf_Internal_Sym *sym;
9015                   bfd_vma val;
9016                   enum {no_check, check_lo, check_ha} insn_check;
9017
9018                   r_type = ELF64_R_TYPE (rel->r_info);
9019                   switch (r_type)
9020                     {
9021                     default:
9022                       insn_check = no_check;
9023                       break;
9024
9025                     case R_PPC64_GOT_TLSLD16_HA:
9026                     case R_PPC64_GOT_TLSGD16_HA:
9027                     case R_PPC64_GOT_TPREL16_HA:
9028                     case R_PPC64_GOT_DTPREL16_HA:
9029                     case R_PPC64_GOT16_HA:
9030                     case R_PPC64_TOC16_HA:
9031                       insn_check = check_ha;
9032                       break;
9033
9034                     case R_PPC64_GOT_TLSLD16_LO:
9035                     case R_PPC64_GOT_TLSGD16_LO:
9036                     case R_PPC64_GOT_TPREL16_LO_DS:
9037                     case R_PPC64_GOT_DTPREL16_LO_DS:
9038                     case R_PPC64_GOT16_LO:
9039                     case R_PPC64_GOT16_LO_DS:
9040                     case R_PPC64_TOC16_LO:
9041                     case R_PPC64_TOC16_LO_DS:
9042                       insn_check = check_lo;
9043                       break;
9044                     }
9045
9046                   if (insn_check != no_check)
9047                     {
9048                       bfd_vma off = rel->r_offset & ~3;
9049                       unsigned char buf[4];
9050                       unsigned int insn;
9051
9052                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9053                         {
9054                           free (used);
9055                           goto error_ret;
9056                         }
9057                       insn = bfd_get_32 (ibfd, buf);
9058                       if (insn_check == check_lo
9059                           ? !ok_lo_toc_insn (insn)
9060                           : ((insn & ((0x3f << 26) | 0x1f << 16))
9061                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9062                         {
9063                           char str[12];
9064
9065                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9066                           sprintf (str, "%#08x", insn);
9067                           info->callbacks->einfo
9068                             (_("%P: %H: toc optimization is not supported for"
9069                                " %s instruction.\n"),
9070                              ibfd, sec, rel->r_offset & ~3, str);
9071                         }
9072                     }
9073
9074                   switch (r_type)
9075                     {
9076                     case R_PPC64_TOC16:
9077                     case R_PPC64_TOC16_LO:
9078                     case R_PPC64_TOC16_HI:
9079                     case R_PPC64_TOC16_HA:
9080                     case R_PPC64_TOC16_DS:
9081                     case R_PPC64_TOC16_LO_DS:
9082                       /* In case we're taking addresses of toc entries.  */
9083                     case R_PPC64_ADDR64:
9084                       break;
9085
9086                     default:
9087                       continue;
9088                     }
9089
9090                   r_symndx = ELF64_R_SYM (rel->r_info);
9091                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9092                                   r_symndx, ibfd))
9093                     {
9094                       free (used);
9095                       goto error_ret;
9096                     }
9097
9098                   if (sym_sec != toc)
9099                     continue;
9100
9101                   if (h != NULL)
9102                     val = h->root.u.def.value;
9103                   else
9104                     val = sym->st_value;
9105                   val += rel->r_addend;
9106
9107                   if (val >= toc->size)
9108                     continue;
9109
9110                   if ((skip[val >> 3] & can_optimize) != 0)
9111                     {
9112                       bfd_vma off;
9113                       unsigned char opc;
9114
9115                       switch (r_type)
9116                         {
9117                         case R_PPC64_TOC16_HA:
9118                           break;
9119
9120                         case R_PPC64_TOC16_LO_DS:
9121                           off = rel->r_offset;
9122                           off += (bfd_big_endian (ibfd) ? -2 : 3);
9123                           if (!bfd_get_section_contents (ibfd, sec, &opc,
9124                                                          off, 1))
9125                             {
9126                               free (used);
9127                               goto error_ret;
9128                             }
9129                           if ((opc & (0x3f << 2)) == (58u << 2))
9130                             break;
9131                           /* Fall thru */
9132
9133                         default:
9134                           /* Wrong sort of reloc, or not a ld.  We may
9135                              as well clear ref_from_discarded too.  */
9136                           skip[val >> 3] = 0;
9137                         }
9138                     }
9139
9140                   if (sec != toc)
9141                     used[val >> 3] = 1;
9142                   /* For the toc section, we only mark as used if this
9143                      entry itself isn't unused.  */
9144                   else if ((used[rel->r_offset >> 3]
9145                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9146                            && !used[val >> 3])
9147                     {
9148                       /* Do all the relocs again, to catch reference
9149                          chains.  */
9150                       repeat = 1;
9151                       used[val >> 3] = 1;
9152                     }
9153                 }
9154             }
9155           while (repeat);
9156
9157           if (elf_section_data (sec)->relocs != relstart)
9158             free (relstart);
9159         }
9160
9161       /* Merge the used and skip arrays.  Assume that TOC
9162          doublewords not appearing as either used or unused belong
9163          to to an entry more than one doubleword in size.  */
9164       for (drop = skip, keep = used, last = 0, some_unused = 0;
9165            drop < skip + (toc->size + 7) / 8;
9166            ++drop, ++keep)
9167         {
9168           if (*keep)
9169             {
9170               *drop &= ~ref_from_discarded;
9171               if ((*drop & can_optimize) != 0)
9172                 some_unused = 1;
9173               last = 0;
9174             }
9175           else if ((*drop & ref_from_discarded) != 0)
9176             {
9177               some_unused = 1;
9178               last = ref_from_discarded;
9179             }
9180           else
9181             *drop = last;
9182         }
9183
9184       free (used);
9185
9186       if (some_unused)
9187         {
9188           bfd_byte *contents, *src;
9189           unsigned long off;
9190           Elf_Internal_Sym *sym;
9191           bfd_boolean local_toc_syms = FALSE;
9192
9193           /* Shuffle the toc contents, and at the same time convert the
9194              skip array from booleans into offsets.  */
9195           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9196             goto error_ret;
9197
9198           elf_section_data (toc)->this_hdr.contents = contents;
9199
9200           for (src = contents, off = 0, drop = skip;
9201                src < contents + toc->size;
9202                src += 8, ++drop)
9203             {
9204               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9205                 off += 8;
9206               else if (off != 0)
9207                 {
9208                   *drop = off;
9209                   memcpy (src - off, src, 8);
9210                 }
9211             }
9212           *drop = off;
9213           toc->rawsize = toc->size;
9214           toc->size = src - contents - off;
9215
9216           /* Adjust addends for relocs against the toc section sym,
9217              and optimize any accesses we can.  */
9218           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9219             {
9220               if (sec->reloc_count == 0
9221                   || discarded_section (sec))
9222                 continue;
9223
9224               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9225                                                     info->keep_memory);
9226               if (relstart == NULL)
9227                 goto error_ret;
9228
9229               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9230                 {
9231                   enum elf_ppc64_reloc_type r_type;
9232                   unsigned long r_symndx;
9233                   asection *sym_sec;
9234                   struct elf_link_hash_entry *h;
9235                   bfd_vma val;
9236
9237                   r_type = ELF64_R_TYPE (rel->r_info);
9238                   switch (r_type)
9239                     {
9240                     default:
9241                       continue;
9242
9243                     case R_PPC64_TOC16:
9244                     case R_PPC64_TOC16_LO:
9245                     case R_PPC64_TOC16_HI:
9246                     case R_PPC64_TOC16_HA:
9247                     case R_PPC64_TOC16_DS:
9248                     case R_PPC64_TOC16_LO_DS:
9249                     case R_PPC64_ADDR64:
9250                       break;
9251                     }
9252
9253                   r_symndx = ELF64_R_SYM (rel->r_info);
9254                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9255                                   r_symndx, ibfd))
9256                     goto error_ret;
9257
9258                   if (sym_sec != toc)
9259                     continue;
9260
9261                   if (h != NULL)
9262                     val = h->root.u.def.value;
9263                   else
9264                     {
9265                       val = sym->st_value;
9266                       if (val != 0)
9267                         local_toc_syms = TRUE;
9268                     }
9269
9270                   val += rel->r_addend;
9271
9272                   if (val > toc->rawsize)
9273                     val = toc->rawsize;
9274                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9275                     continue;
9276                   else if ((skip[val >> 3] & can_optimize) != 0)
9277                     {
9278                       Elf_Internal_Rela *tocrel
9279                         = toc_relocs + (skip[val >> 3] >> 2);
9280                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9281
9282                       switch (r_type)
9283                         {
9284                         case R_PPC64_TOC16_HA:
9285                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9286                           break;
9287
9288                         case R_PPC64_TOC16_LO_DS:
9289                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9290                           break;
9291
9292                         default:
9293                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9294                             ppc_howto_init ();
9295                           info->callbacks->einfo
9296                             (_("%P: %H: %s references "
9297                                "optimized away TOC entry\n"),
9298                              ibfd, sec, rel->r_offset,
9299                              ppc64_elf_howto_table[r_type]->name);
9300                           bfd_set_error (bfd_error_bad_value);
9301                           goto error_ret;
9302                         }
9303                       rel->r_addend = tocrel->r_addend;
9304                       elf_section_data (sec)->relocs = relstart;
9305                       continue;
9306                     }
9307
9308                   if (h != NULL || sym->st_value != 0)
9309                     continue;
9310
9311                   rel->r_addend -= skip[val >> 3];
9312                   elf_section_data (sec)->relocs = relstart;
9313                 }
9314
9315               if (elf_section_data (sec)->relocs != relstart)
9316                 free (relstart);
9317             }
9318
9319           /* We shouldn't have local or global symbols defined in the TOC,
9320              but handle them anyway.  */
9321           if (local_syms != NULL)
9322             for (sym = local_syms;
9323                  sym < local_syms + symtab_hdr->sh_info;
9324                  ++sym)
9325               if (sym->st_value != 0
9326                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9327                 {
9328                   unsigned long i;
9329
9330                   if (sym->st_value > toc->rawsize)
9331                     i = toc->rawsize >> 3;
9332                   else
9333                     i = sym->st_value >> 3;
9334
9335                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9336                     {
9337                       if (local_toc_syms)
9338                         (*_bfd_error_handler)
9339                           (_("%s defined on removed toc entry"),
9340                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9341                       do
9342                         ++i;
9343                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9344                       sym->st_value = (bfd_vma) i << 3;
9345                     }
9346
9347                   sym->st_value -= skip[i];
9348                   symtab_hdr->contents = (unsigned char *) local_syms;
9349                 }
9350
9351           /* Adjust any global syms defined in this toc input section.  */
9352           if (toc_inf.global_toc_syms)
9353             {
9354               toc_inf.toc = toc;
9355               toc_inf.skip = skip;
9356               toc_inf.global_toc_syms = FALSE;
9357               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9358                                       &toc_inf);
9359             }
9360
9361           if (toc->reloc_count != 0)
9362             {
9363               Elf_Internal_Shdr *rel_hdr;
9364               Elf_Internal_Rela *wrel;
9365               bfd_size_type sz;
9366
9367               /* Remove unused toc relocs, and adjust those we keep.  */
9368               if (toc_relocs == NULL)
9369                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9370                                                         info->keep_memory);
9371               if (toc_relocs == NULL)
9372                 goto error_ret;
9373
9374               wrel = toc_relocs;
9375               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9376                 if ((skip[rel->r_offset >> 3]
9377                      & (ref_from_discarded | can_optimize)) == 0)
9378                   {
9379                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9380                     wrel->r_info = rel->r_info;
9381                     wrel->r_addend = rel->r_addend;
9382                     ++wrel;
9383                   }
9384                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9385                                             &local_syms, NULL, NULL))
9386                   goto error_ret;
9387
9388               elf_section_data (toc)->relocs = toc_relocs;
9389               toc->reloc_count = wrel - toc_relocs;
9390               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9391               sz = rel_hdr->sh_entsize;
9392               rel_hdr->sh_size = toc->reloc_count * sz;
9393             }
9394         }
9395       else if (toc_relocs != NULL
9396                && elf_section_data (toc)->relocs != toc_relocs)
9397         free (toc_relocs);
9398
9399       if (local_syms != NULL
9400           && symtab_hdr->contents != (unsigned char *) local_syms)
9401         {
9402           if (!info->keep_memory)
9403             free (local_syms);
9404           else
9405             symtab_hdr->contents = (unsigned char *) local_syms;
9406         }
9407       free (skip);
9408     }
9409
9410   return TRUE;
9411 }
9412
9413 /* Return true iff input section I references the TOC using
9414    instructions limited to +/-32k offsets.  */
9415
9416 bfd_boolean
9417 ppc64_elf_has_small_toc_reloc (asection *i)
9418 {
9419   return (is_ppc64_elf (i->owner)
9420           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9421 }
9422
9423 /* Allocate space for one GOT entry.  */
9424
9425 static void
9426 allocate_got (struct elf_link_hash_entry *h,
9427               struct bfd_link_info *info,
9428               struct got_entry *gent)
9429 {
9430   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9431   bfd_boolean dyn;
9432   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9433   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9434                  ? 16 : 8);
9435   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9436                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9437   asection *got = ppc64_elf_tdata (gent->owner)->got;
9438
9439   gent->got.offset = got->size;
9440   got->size += entsize;
9441
9442   dyn = htab->elf.dynamic_sections_created;
9443   if (h->type == STT_GNU_IFUNC)
9444     {
9445       htab->elf.irelplt->size += rentsize;
9446       htab->got_reli_size += rentsize;
9447     }
9448   else if ((bfd_link_pic (info)
9449             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9450            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9451                || h->root.type != bfd_link_hash_undefweak))
9452     {
9453       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9454       relgot->size += rentsize;
9455     }
9456 }
9457
9458 /* This function merges got entries in the same toc group.  */
9459
9460 static void
9461 merge_got_entries (struct got_entry **pent)
9462 {
9463   struct got_entry *ent, *ent2;
9464
9465   for (ent = *pent; ent != NULL; ent = ent->next)
9466     if (!ent->is_indirect)
9467       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9468         if (!ent2->is_indirect
9469             && ent2->addend == ent->addend
9470             && ent2->tls_type == ent->tls_type
9471             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9472           {
9473             ent2->is_indirect = TRUE;
9474             ent2->got.ent = ent;
9475           }
9476 }
9477
9478 /* Allocate space in .plt, .got and associated reloc sections for
9479    dynamic relocs.  */
9480
9481 static bfd_boolean
9482 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9483 {
9484   struct bfd_link_info *info;
9485   struct ppc_link_hash_table *htab;
9486   asection *s;
9487   struct ppc_link_hash_entry *eh;
9488   struct elf_dyn_relocs *p;
9489   struct got_entry **pgent, *gent;
9490
9491   if (h->root.type == bfd_link_hash_indirect)
9492     return TRUE;
9493
9494   info = (struct bfd_link_info *) inf;
9495   htab = ppc_hash_table (info);
9496   if (htab == NULL)
9497     return FALSE;
9498
9499   if ((htab->elf.dynamic_sections_created
9500        && h->dynindx != -1
9501        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9502       || h->type == STT_GNU_IFUNC)
9503     {
9504       struct plt_entry *pent;
9505       bfd_boolean doneone = FALSE;
9506       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9507         if (pent->plt.refcount > 0)
9508           {
9509             if (!htab->elf.dynamic_sections_created
9510                 || h->dynindx == -1)
9511               {
9512                 s = htab->elf.iplt;
9513                 pent->plt.offset = s->size;
9514                 s->size += PLT_ENTRY_SIZE (htab);
9515                 s = htab->elf.irelplt;
9516               }
9517             else
9518               {
9519                 /* If this is the first .plt entry, make room for the special
9520                    first entry.  */
9521                 s = htab->elf.splt;
9522                 if (s->size == 0)
9523                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9524
9525                 pent->plt.offset = s->size;
9526
9527                 /* Make room for this entry.  */
9528                 s->size += PLT_ENTRY_SIZE (htab);
9529
9530                 /* Make room for the .glink code.  */
9531                 s = htab->glink;
9532                 if (s->size == 0)
9533                   s->size += GLINK_CALL_STUB_SIZE;
9534                 if (htab->opd_abi)
9535                   {
9536                     /* We need bigger stubs past index 32767.  */
9537                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9538                       s->size += 4;
9539                     s->size += 2*4;
9540                   }
9541                 else
9542                   s->size += 4;
9543
9544                 /* We also need to make an entry in the .rela.plt section.  */
9545                 s = htab->elf.srelplt;
9546               }
9547             s->size += sizeof (Elf64_External_Rela);
9548             doneone = TRUE;
9549           }
9550         else
9551           pent->plt.offset = (bfd_vma) -1;
9552       if (!doneone)
9553         {
9554           h->plt.plist = NULL;
9555           h->needs_plt = 0;
9556         }
9557     }
9558   else
9559     {
9560       h->plt.plist = NULL;
9561       h->needs_plt = 0;
9562     }
9563
9564   eh = (struct ppc_link_hash_entry *) h;
9565   /* Run through the TLS GD got entries first if we're changing them
9566      to TPREL.  */
9567   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9568     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9569       if (gent->got.refcount > 0
9570           && (gent->tls_type & TLS_GD) != 0)
9571         {
9572           /* This was a GD entry that has been converted to TPREL.  If
9573              there happens to be a TPREL entry we can use that one.  */
9574           struct got_entry *ent;
9575           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9576             if (ent->got.refcount > 0
9577                 && (ent->tls_type & TLS_TPREL) != 0
9578                 && ent->addend == gent->addend
9579                 && ent->owner == gent->owner)
9580               {
9581                 gent->got.refcount = 0;
9582                 break;
9583               }
9584
9585           /* If not, then we'll be using our own TPREL entry.  */
9586           if (gent->got.refcount != 0)
9587             gent->tls_type = TLS_TLS | TLS_TPREL;
9588         }
9589
9590   /* Remove any list entry that won't generate a word in the GOT before
9591      we call merge_got_entries.  Otherwise we risk merging to empty
9592      entries.  */
9593   pgent = &h->got.glist;
9594   while ((gent = *pgent) != NULL)
9595     if (gent->got.refcount > 0)
9596       {
9597         if ((gent->tls_type & TLS_LD) != 0
9598             && !h->def_dynamic)
9599           {
9600             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9601             *pgent = gent->next;
9602           }
9603         else
9604           pgent = &gent->next;
9605       }
9606     else
9607       *pgent = gent->next;
9608
9609   if (!htab->do_multi_toc)
9610     merge_got_entries (&h->got.glist);
9611
9612   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9613     if (!gent->is_indirect)
9614       {
9615         /* Make sure this symbol is output as a dynamic symbol.
9616            Undefined weak syms won't yet be marked as dynamic,
9617            nor will all TLS symbols.  */
9618         if (h->dynindx == -1
9619             && !h->forced_local
9620             && h->type != STT_GNU_IFUNC
9621             && htab->elf.dynamic_sections_created)
9622           {
9623             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9624               return FALSE;
9625           }
9626
9627         if (!is_ppc64_elf (gent->owner))
9628           abort ();
9629
9630         allocate_got (h, info, gent);
9631       }
9632
9633   if (eh->dyn_relocs == NULL
9634       || (!htab->elf.dynamic_sections_created
9635           && h->type != STT_GNU_IFUNC))
9636     return TRUE;
9637
9638   /* In the shared -Bsymbolic case, discard space allocated for
9639      dynamic pc-relative relocs against symbols which turn out to be
9640      defined in regular objects.  For the normal shared case, discard
9641      space for relocs that have become local due to symbol visibility
9642      changes.  */
9643
9644   if (bfd_link_pic (info))
9645     {
9646       /* Relocs that use pc_count are those that appear on a call insn,
9647          or certain REL relocs (see must_be_dyn_reloc) that can be
9648          generated via assembly.  We want calls to protected symbols to
9649          resolve directly to the function rather than going via the plt.
9650          If people want function pointer comparisons to work as expected
9651          then they should avoid writing weird assembly.  */
9652       if (SYMBOL_CALLS_LOCAL (info, h))
9653         {
9654           struct elf_dyn_relocs **pp;
9655
9656           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9657             {
9658               p->count -= p->pc_count;
9659               p->pc_count = 0;
9660               if (p->count == 0)
9661                 *pp = p->next;
9662               else
9663                 pp = &p->next;
9664             }
9665         }
9666
9667       /* Also discard relocs on undefined weak syms with non-default
9668          visibility.  */
9669       if (eh->dyn_relocs != NULL
9670           && h->root.type == bfd_link_hash_undefweak)
9671         {
9672           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9673             eh->dyn_relocs = NULL;
9674
9675           /* Make sure this symbol is output as a dynamic symbol.
9676              Undefined weak syms won't yet be marked as dynamic.  */
9677           else if (h->dynindx == -1
9678                    && !h->forced_local)
9679             {
9680               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9681                 return FALSE;
9682             }
9683         }
9684     }
9685   else if (h->type == STT_GNU_IFUNC)
9686     {
9687       if (!h->non_got_ref)
9688         eh->dyn_relocs = NULL;
9689     }
9690   else if (ELIMINATE_COPY_RELOCS)
9691     {
9692       /* For the non-shared case, discard space for relocs against
9693          symbols which turn out to need copy relocs or are not
9694          dynamic.  */
9695
9696       if (!h->non_got_ref
9697           && !h->def_regular)
9698         {
9699           /* Make sure this symbol is output as a dynamic symbol.
9700              Undefined weak syms won't yet be marked as dynamic.  */
9701           if (h->dynindx == -1
9702               && !h->forced_local)
9703             {
9704               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9705                 return FALSE;
9706             }
9707
9708           /* If that succeeded, we know we'll be keeping all the
9709              relocs.  */
9710           if (h->dynindx != -1)
9711             goto keep;
9712         }
9713
9714       eh->dyn_relocs = NULL;
9715
9716     keep: ;
9717     }
9718
9719   /* Finally, allocate space.  */
9720   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9721     {
9722       asection *sreloc = elf_section_data (p->sec)->sreloc;
9723       if (eh->elf.type == STT_GNU_IFUNC)
9724         sreloc = htab->elf.irelplt;
9725       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9726     }
9727
9728   return TRUE;
9729 }
9730
9731 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9732    to set up space for global entry stubs.  These are put in glink,
9733    after the branch table.  */
9734
9735 static bfd_boolean
9736 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9737 {
9738   struct bfd_link_info *info;
9739   struct ppc_link_hash_table *htab;
9740   struct plt_entry *pent;
9741   asection *s;
9742
9743   if (h->root.type == bfd_link_hash_indirect)
9744     return TRUE;
9745
9746   if (!h->pointer_equality_needed)
9747     return TRUE;
9748
9749   if (h->def_regular)
9750     return TRUE;
9751
9752   info = inf;
9753   htab = ppc_hash_table (info);
9754   if (htab == NULL)
9755     return FALSE;
9756
9757   s = htab->glink;
9758   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9759     if (pent->plt.offset != (bfd_vma) -1
9760         && pent->addend == 0)
9761       {
9762         /* For ELFv2, if this symbol is not defined in a regular file
9763            and we are not generating a shared library or pie, then we
9764            need to define the symbol in the executable on a call stub.
9765            This is to avoid text relocations.  */
9766         s->size = (s->size + 15) & -16;
9767         h->root.u.def.section = s;
9768         h->root.u.def.value = s->size;
9769         s->size += 16;
9770         break;
9771       }
9772   return TRUE;
9773 }
9774
9775 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9776    read-only sections.  */
9777
9778 static bfd_boolean
9779 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9780 {
9781   if (h->root.type == bfd_link_hash_indirect)
9782     return TRUE;
9783
9784   if (readonly_dynrelocs (h))
9785     {
9786       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9787
9788       /* Not an error, just cut short the traversal.  */
9789       return FALSE;
9790     }
9791   return TRUE;
9792 }
9793
9794 /* Set the sizes of the dynamic sections.  */
9795
9796 static bfd_boolean
9797 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9798                                  struct bfd_link_info *info)
9799 {
9800   struct ppc_link_hash_table *htab;
9801   bfd *dynobj;
9802   asection *s;
9803   bfd_boolean relocs;
9804   bfd *ibfd;
9805   struct got_entry *first_tlsld;
9806
9807   htab = ppc_hash_table (info);
9808   if (htab == NULL)
9809     return FALSE;
9810
9811   dynobj = htab->elf.dynobj;
9812   if (dynobj == NULL)
9813     abort ();
9814
9815   if (htab->elf.dynamic_sections_created)
9816     {
9817       /* Set the contents of the .interp section to the interpreter.  */
9818       if (bfd_link_executable (info) && !info->nointerp)
9819         {
9820           s = bfd_get_linker_section (dynobj, ".interp");
9821           if (s == NULL)
9822             abort ();
9823           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9824           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9825         }
9826     }
9827
9828   /* Set up .got offsets for local syms, and space for local dynamic
9829      relocs.  */
9830   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9831     {
9832       struct got_entry **lgot_ents;
9833       struct got_entry **end_lgot_ents;
9834       struct plt_entry **local_plt;
9835       struct plt_entry **end_local_plt;
9836       unsigned char *lgot_masks;
9837       bfd_size_type locsymcount;
9838       Elf_Internal_Shdr *symtab_hdr;
9839
9840       if (!is_ppc64_elf (ibfd))
9841         continue;
9842
9843       for (s = ibfd->sections; s != NULL; s = s->next)
9844         {
9845           struct ppc_dyn_relocs *p;
9846
9847           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9848             {
9849               if (!bfd_is_abs_section (p->sec)
9850                   && bfd_is_abs_section (p->sec->output_section))
9851                 {
9852                   /* Input section has been discarded, either because
9853                      it is a copy of a linkonce section or due to
9854                      linker script /DISCARD/, so we'll be discarding
9855                      the relocs too.  */
9856                 }
9857               else if (p->count != 0)
9858                 {
9859                   asection *srel = elf_section_data (p->sec)->sreloc;
9860                   if (p->ifunc)
9861                     srel = htab->elf.irelplt;
9862                   srel->size += p->count * sizeof (Elf64_External_Rela);
9863                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9864                     info->flags |= DF_TEXTREL;
9865                 }
9866             }
9867         }
9868
9869       lgot_ents = elf_local_got_ents (ibfd);
9870       if (!lgot_ents)
9871         continue;
9872
9873       symtab_hdr = &elf_symtab_hdr (ibfd);
9874       locsymcount = symtab_hdr->sh_info;
9875       end_lgot_ents = lgot_ents + locsymcount;
9876       local_plt = (struct plt_entry **) end_lgot_ents;
9877       end_local_plt = local_plt + locsymcount;
9878       lgot_masks = (unsigned char *) end_local_plt;
9879       s = ppc64_elf_tdata (ibfd)->got;
9880       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9881         {
9882           struct got_entry **pent, *ent;
9883
9884           pent = lgot_ents;
9885           while ((ent = *pent) != NULL)
9886             if (ent->got.refcount > 0)
9887               {
9888                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9889                   {
9890                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9891                     *pent = ent->next;
9892                   }
9893                 else
9894                   {
9895                     unsigned int ent_size = 8;
9896                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9897
9898                     ent->got.offset = s->size;
9899                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9900                       {
9901                         ent_size *= 2;
9902                         rel_size *= 2;
9903                       }
9904                     s->size += ent_size;
9905                     if ((*lgot_masks & PLT_IFUNC) != 0)
9906                       {
9907                         htab->elf.irelplt->size += rel_size;
9908                         htab->got_reli_size += rel_size;
9909                       }
9910                     else if (bfd_link_pic (info))
9911                       {
9912                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9913                         srel->size += rel_size;
9914                       }
9915                     pent = &ent->next;
9916                   }
9917               }
9918             else
9919               *pent = ent->next;
9920         }
9921
9922       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9923       for (; local_plt < end_local_plt; ++local_plt)
9924         {
9925           struct plt_entry *ent;
9926
9927           for (ent = *local_plt; ent != NULL; ent = ent->next)
9928             if (ent->plt.refcount > 0)
9929               {
9930                 s = htab->elf.iplt;
9931                 ent->plt.offset = s->size;
9932                 s->size += PLT_ENTRY_SIZE (htab);
9933
9934                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9935               }
9936             else
9937               ent->plt.offset = (bfd_vma) -1;
9938         }
9939     }
9940
9941   /* Allocate global sym .plt and .got entries, and space for global
9942      sym dynamic relocs.  */
9943   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9944   /* Stash the end of glink branch table.  */
9945   if (htab->glink != NULL)
9946     htab->glink->rawsize = htab->glink->size;
9947
9948   if (!htab->opd_abi && !bfd_link_pic (info))
9949     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9950
9951   first_tlsld = NULL;
9952   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9953     {
9954       struct got_entry *ent;
9955
9956       if (!is_ppc64_elf (ibfd))
9957         continue;
9958
9959       ent = ppc64_tlsld_got (ibfd);
9960       if (ent->got.refcount > 0)
9961         {
9962           if (!htab->do_multi_toc && first_tlsld != NULL)
9963             {
9964               ent->is_indirect = TRUE;
9965               ent->got.ent = first_tlsld;
9966             }
9967           else
9968             {
9969               if (first_tlsld == NULL)
9970                 first_tlsld = ent;
9971               s = ppc64_elf_tdata (ibfd)->got;
9972               ent->got.offset = s->size;
9973               ent->owner = ibfd;
9974               s->size += 16;
9975               if (bfd_link_pic (info))
9976                 {
9977                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9978                   srel->size += sizeof (Elf64_External_Rela);
9979                 }
9980             }
9981         }
9982       else
9983         ent->got.offset = (bfd_vma) -1;
9984     }
9985
9986   /* We now have determined the sizes of the various dynamic sections.
9987      Allocate memory for them.  */
9988   relocs = FALSE;
9989   for (s = dynobj->sections; s != NULL; s = s->next)
9990     {
9991       if ((s->flags & SEC_LINKER_CREATED) == 0)
9992         continue;
9993
9994       if (s == htab->brlt || s == htab->relbrlt)
9995         /* These haven't been allocated yet;  don't strip.  */
9996         continue;
9997       else if (s == htab->elf.sgot
9998                || s == htab->elf.splt
9999                || s == htab->elf.iplt
10000                || s == htab->glink
10001                || s == htab->dynbss)
10002         {
10003           /* Strip this section if we don't need it; see the
10004              comment below.  */
10005         }
10006       else if (s == htab->glink_eh_frame)
10007         {
10008           if (!bfd_is_abs_section (s->output_section))
10009             /* Not sized yet.  */
10010             continue;
10011         }
10012       else if (CONST_STRNEQ (s->name, ".rela"))
10013         {
10014           if (s->size != 0)
10015             {
10016               if (s != htab->elf.srelplt)
10017                 relocs = TRUE;
10018
10019               /* We use the reloc_count field as a counter if we need
10020                  to copy relocs into the output file.  */
10021               s->reloc_count = 0;
10022             }
10023         }
10024       else
10025         {
10026           /* It's not one of our sections, so don't allocate space.  */
10027           continue;
10028         }
10029
10030       if (s->size == 0)
10031         {
10032           /* If we don't need this section, strip it from the
10033              output file.  This is mostly to handle .rela.bss and
10034              .rela.plt.  We must create both sections in
10035              create_dynamic_sections, because they must be created
10036              before the linker maps input sections to output
10037              sections.  The linker does that before
10038              adjust_dynamic_symbol is called, and it is that
10039              function which decides whether anything needs to go
10040              into these sections.  */
10041           s->flags |= SEC_EXCLUDE;
10042           continue;
10043         }
10044
10045       if ((s->flags & SEC_HAS_CONTENTS) == 0)
10046         continue;
10047
10048       /* Allocate memory for the section contents.  We use bfd_zalloc
10049          here in case unused entries are not reclaimed before the
10050          section's contents are written out.  This should not happen,
10051          but this way if it does we get a R_PPC64_NONE reloc in .rela
10052          sections instead of garbage.
10053          We also rely on the section contents being zero when writing
10054          the GOT.  */
10055       s->contents = bfd_zalloc (dynobj, s->size);
10056       if (s->contents == NULL)
10057         return FALSE;
10058     }
10059
10060   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10061     {
10062       if (!is_ppc64_elf (ibfd))
10063         continue;
10064
10065       s = ppc64_elf_tdata (ibfd)->got;
10066       if (s != NULL && s != htab->elf.sgot)
10067         {
10068           if (s->size == 0)
10069             s->flags |= SEC_EXCLUDE;
10070           else
10071             {
10072               s->contents = bfd_zalloc (ibfd, s->size);
10073               if (s->contents == NULL)
10074                 return FALSE;
10075             }
10076         }
10077       s = ppc64_elf_tdata (ibfd)->relgot;
10078       if (s != NULL)
10079         {
10080           if (s->size == 0)
10081             s->flags |= SEC_EXCLUDE;
10082           else
10083             {
10084               s->contents = bfd_zalloc (ibfd, s->size);
10085               if (s->contents == NULL)
10086                 return FALSE;
10087               relocs = TRUE;
10088               s->reloc_count = 0;
10089             }
10090         }
10091     }
10092
10093   if (htab->elf.dynamic_sections_created)
10094     {
10095       bfd_boolean tls_opt;
10096
10097       /* Add some entries to the .dynamic section.  We fill in the
10098          values later, in ppc64_elf_finish_dynamic_sections, but we
10099          must add the entries now so that we get the correct size for
10100          the .dynamic section.  The DT_DEBUG entry is filled in by the
10101          dynamic linker and used by the debugger.  */
10102 #define add_dynamic_entry(TAG, VAL) \
10103   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10104
10105       if (bfd_link_executable (info))
10106         {
10107           if (!add_dynamic_entry (DT_DEBUG, 0))
10108             return FALSE;
10109         }
10110
10111       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10112         {
10113           if (!add_dynamic_entry (DT_PLTGOT, 0)
10114               || !add_dynamic_entry (DT_PLTRELSZ, 0)
10115               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10116               || !add_dynamic_entry (DT_JMPREL, 0)
10117               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10118             return FALSE;
10119         }
10120
10121       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10122         {
10123           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10124               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10125             return FALSE;
10126         }
10127
10128       tls_opt = (htab->params->tls_get_addr_opt
10129                  && htab->tls_get_addr_fd != NULL
10130                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10131       if (tls_opt || !htab->opd_abi)
10132         {
10133           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10134             return FALSE;
10135         }
10136
10137       if (relocs)
10138         {
10139           if (!add_dynamic_entry (DT_RELA, 0)
10140               || !add_dynamic_entry (DT_RELASZ, 0)
10141               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10142             return FALSE;
10143
10144           /* If any dynamic relocs apply to a read-only section,
10145              then we need a DT_TEXTREL entry.  */
10146           if ((info->flags & DF_TEXTREL) == 0)
10147             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10148
10149           if ((info->flags & DF_TEXTREL) != 0)
10150             {
10151               if (!add_dynamic_entry (DT_TEXTREL, 0))
10152                 return FALSE;
10153             }
10154         }
10155     }
10156 #undef add_dynamic_entry
10157
10158   return TRUE;
10159 }
10160
10161 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10162
10163 static bfd_boolean
10164 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10165 {
10166   if (h->plt.plist != NULL
10167       && !h->def_regular
10168       && !h->pointer_equality_needed)
10169     return FALSE;
10170
10171   return _bfd_elf_hash_symbol (h);
10172 }
10173
10174 /* Determine the type of stub needed, if any, for a call.  */
10175
10176 static inline enum ppc_stub_type
10177 ppc_type_of_stub (asection *input_sec,
10178                   const Elf_Internal_Rela *rel,
10179                   struct ppc_link_hash_entry **hash,
10180                   struct plt_entry **plt_ent,
10181                   bfd_vma destination,
10182                   unsigned long local_off)
10183 {
10184   struct ppc_link_hash_entry *h = *hash;
10185   bfd_vma location;
10186   bfd_vma branch_offset;
10187   bfd_vma max_branch_offset;
10188   enum elf_ppc64_reloc_type r_type;
10189
10190   if (h != NULL)
10191     {
10192       struct plt_entry *ent;
10193       struct ppc_link_hash_entry *fdh = h;
10194       if (h->oh != NULL
10195           && h->oh->is_func_descriptor)
10196         {
10197           fdh = ppc_follow_link (h->oh);
10198           *hash = fdh;
10199         }
10200
10201       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10202         if (ent->addend == rel->r_addend
10203             && ent->plt.offset != (bfd_vma) -1)
10204           {
10205             *plt_ent = ent;
10206             return ppc_stub_plt_call;
10207           }
10208
10209       /* Here, we know we don't have a plt entry.  If we don't have a
10210          either a defined function descriptor or a defined entry symbol
10211          in a regular object file, then it is pointless trying to make
10212          any other type of stub.  */
10213       if (!is_static_defined (&fdh->elf)
10214           && !is_static_defined (&h->elf))
10215         return ppc_stub_none;
10216     }
10217   else if (elf_local_got_ents (input_sec->owner) != NULL)
10218     {
10219       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10220       struct plt_entry **local_plt = (struct plt_entry **)
10221         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10222       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10223
10224       if (local_plt[r_symndx] != NULL)
10225         {
10226           struct plt_entry *ent;
10227
10228           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10229             if (ent->addend == rel->r_addend
10230                 && ent->plt.offset != (bfd_vma) -1)
10231               {
10232                 *plt_ent = ent;
10233                 return ppc_stub_plt_call;
10234               }
10235         }
10236     }
10237
10238   /* Determine where the call point is.  */
10239   location = (input_sec->output_offset
10240               + input_sec->output_section->vma
10241               + rel->r_offset);
10242
10243   branch_offset = destination - location;
10244   r_type = ELF64_R_TYPE (rel->r_info);
10245
10246   /* Determine if a long branch stub is needed.  */
10247   max_branch_offset = 1 << 25;
10248   if (r_type != R_PPC64_REL24)
10249     max_branch_offset = 1 << 15;
10250
10251   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10252     /* We need a stub.  Figure out whether a long_branch or plt_branch
10253        is needed later.  */
10254     return ppc_stub_long_branch;
10255
10256   return ppc_stub_none;
10257 }
10258
10259 /* With power7 weakly ordered memory model, it is possible for ld.so
10260    to update a plt entry in one thread and have another thread see a
10261    stale zero toc entry.  To avoid this we need some sort of acquire
10262    barrier in the call stub.  One solution is to make the load of the
10263    toc word seem to appear to depend on the load of the function entry
10264    word.  Another solution is to test for r2 being zero, and branch to
10265    the appropriate glink entry if so.
10266
10267    .    fake dep barrier        compare
10268    .    ld 12,xxx(2)            ld 12,xxx(2)
10269    .    mtctr 12                mtctr 12
10270    .    xor 11,12,12            ld 2,xxx+8(2)
10271    .    add 2,2,11              cmpldi 2,0
10272    .    ld 2,xxx+8(2)           bnectr+
10273    .    bctr                    b <glink_entry>
10274
10275    The solution involving the compare turns out to be faster, so
10276    that's what we use unless the branch won't reach.  */
10277
10278 #define ALWAYS_USE_FAKE_DEP 0
10279 #define ALWAYS_EMIT_R2SAVE 0
10280
10281 #define PPC_LO(v) ((v) & 0xffff)
10282 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10283 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10284
10285 static inline unsigned int
10286 plt_stub_size (struct ppc_link_hash_table *htab,
10287                struct ppc_stub_hash_entry *stub_entry,
10288                bfd_vma off)
10289 {
10290   unsigned size = 12;
10291
10292   if (ALWAYS_EMIT_R2SAVE
10293       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10294     size += 4;
10295   if (PPC_HA (off) != 0)
10296     size += 4;
10297   if (htab->opd_abi)
10298     {
10299       size += 4;
10300       if (htab->params->plt_static_chain)
10301         size += 4;
10302       if (htab->params->plt_thread_safe
10303           && htab->elf.dynamic_sections_created
10304           && stub_entry->h != NULL
10305           && stub_entry->h->elf.dynindx != -1)
10306         size += 8;
10307       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10308         size += 4;
10309     }
10310   if (stub_entry->h != NULL
10311       && (stub_entry->h == htab->tls_get_addr_fd
10312           || stub_entry->h == htab->tls_get_addr)
10313       && htab->params->tls_get_addr_opt)
10314     size += 13 * 4;
10315   return size;
10316 }
10317
10318 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10319    then return the padding needed to do so.  */
10320 static inline unsigned int
10321 plt_stub_pad (struct ppc_link_hash_table *htab,
10322               struct ppc_stub_hash_entry *stub_entry,
10323               bfd_vma plt_off)
10324 {
10325   int stub_align = 1 << htab->params->plt_stub_align;
10326   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10327   bfd_vma stub_off = stub_entry->group->stub_sec->size;
10328
10329   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10330       > ((stub_size - 1) & -stub_align))
10331     return stub_align - (stub_off & (stub_align - 1));
10332   return 0;
10333 }
10334
10335 /* Build a .plt call stub.  */
10336
10337 static inline bfd_byte *
10338 build_plt_stub (struct ppc_link_hash_table *htab,
10339                 struct ppc_stub_hash_entry *stub_entry,
10340                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10341 {
10342   bfd *obfd = htab->params->stub_bfd;
10343   bfd_boolean plt_load_toc = htab->opd_abi;
10344   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10345   bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10346                                  && htab->elf.dynamic_sections_created
10347                                  && stub_entry->h != NULL
10348                                  && stub_entry->h->elf.dynindx != -1);
10349   bfd_boolean use_fake_dep = plt_thread_safe;
10350   bfd_vma cmp_branch_off = 0;
10351
10352   if (!ALWAYS_USE_FAKE_DEP
10353       && plt_load_toc
10354       && plt_thread_safe
10355       && !((stub_entry->h == htab->tls_get_addr_fd
10356             || stub_entry->h == htab->tls_get_addr)
10357            && htab->params->tls_get_addr_opt))
10358     {
10359       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10360       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10361                           / PLT_ENTRY_SIZE (htab));
10362       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10363       bfd_vma to, from;
10364
10365       if (pltindex > 32768)
10366         glinkoff += (pltindex - 32768) * 4;
10367       to = (glinkoff
10368             + htab->glink->output_offset
10369             + htab->glink->output_section->vma);
10370       from = (p - stub_entry->group->stub_sec->contents
10371               + 4 * (ALWAYS_EMIT_R2SAVE
10372                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10373               + 4 * (PPC_HA (offset) != 0)
10374               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10375                      != PPC_HA (offset))
10376               + 4 * (plt_static_chain != 0)
10377               + 20
10378               + stub_entry->group->stub_sec->output_offset
10379               + stub_entry->group->stub_sec->output_section->vma);
10380       cmp_branch_off = to - from;
10381       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10382     }
10383
10384   if (PPC_HA (offset) != 0)
10385     {
10386       if (r != NULL)
10387         {
10388           if (ALWAYS_EMIT_R2SAVE
10389               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10390             r[0].r_offset += 4;
10391           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10392           r[1].r_offset = r[0].r_offset + 4;
10393           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10394           r[1].r_addend = r[0].r_addend;
10395           if (plt_load_toc)
10396             {
10397               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10398                 {
10399                   r[2].r_offset = r[1].r_offset + 4;
10400                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10401                   r[2].r_addend = r[0].r_addend;
10402                 }
10403               else
10404                 {
10405                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10406                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10407                   r[2].r_addend = r[0].r_addend + 8;
10408                   if (plt_static_chain)
10409                     {
10410                       r[3].r_offset = r[2].r_offset + 4;
10411                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10412                       r[3].r_addend = r[0].r_addend + 16;
10413                     }
10414                 }
10415             }
10416         }
10417       if (ALWAYS_EMIT_R2SAVE
10418           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10419         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10420       if (plt_load_toc)
10421         {
10422           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10423           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10424         }
10425       else
10426         {
10427           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10428           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10429         }
10430       if (plt_load_toc
10431           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10432         {
10433           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10434           offset = 0;
10435         }
10436       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10437       if (plt_load_toc)
10438         {
10439           if (use_fake_dep)
10440             {
10441               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10442               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10443             }
10444           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10445           if (plt_static_chain)
10446             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10447         }
10448     }
10449   else
10450     {
10451       if (r != NULL)
10452         {
10453           if (ALWAYS_EMIT_R2SAVE
10454               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10455             r[0].r_offset += 4;
10456           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10457           if (plt_load_toc)
10458             {
10459               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10460                 {
10461                   r[1].r_offset = r[0].r_offset + 4;
10462                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10463                   r[1].r_addend = r[0].r_addend;
10464                 }
10465               else
10466                 {
10467                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10468                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10469                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10470                   if (plt_static_chain)
10471                     {
10472                       r[2].r_offset = r[1].r_offset + 4;
10473                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10474                       r[2].r_addend = r[0].r_addend + 8;
10475                     }
10476                 }
10477             }
10478         }
10479       if (ALWAYS_EMIT_R2SAVE
10480           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10481         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10482       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10483       if (plt_load_toc
10484           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10485         {
10486           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10487           offset = 0;
10488         }
10489       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10490       if (plt_load_toc)
10491         {
10492           if (use_fake_dep)
10493             {
10494               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10495               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10496             }
10497           if (plt_static_chain)
10498             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10499           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10500         }
10501     }
10502   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10503     {
10504       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10505       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10506       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10507     }
10508   else
10509     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10510   return p;
10511 }
10512
10513 /* Build a special .plt call stub for __tls_get_addr.  */
10514
10515 #define LD_R11_0R3      0xe9630000
10516 #define LD_R12_0R3      0xe9830000
10517 #define MR_R0_R3        0x7c601b78
10518 #define CMPDI_R11_0     0x2c2b0000
10519 #define ADD_R3_R12_R13  0x7c6c6a14
10520 #define BEQLR           0x4d820020
10521 #define MR_R3_R0        0x7c030378
10522 #define STD_R11_0R1     0xf9610000
10523 #define BCTRL           0x4e800421
10524 #define LD_R11_0R1      0xe9610000
10525 #define MTLR_R11        0x7d6803a6
10526
10527 static inline bfd_byte *
10528 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10529                          struct ppc_stub_hash_entry *stub_entry,
10530                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10531 {
10532   bfd *obfd = htab->params->stub_bfd;
10533
10534   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10535   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10536   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10537   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10538   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10539   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10540   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10541   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10542   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10543
10544   if (r != NULL)
10545     r[0].r_offset += 9 * 4;
10546   p = build_plt_stub (htab, stub_entry, p, offset, r);
10547   bfd_put_32 (obfd, BCTRL, p - 4);
10548
10549   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10550   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10551   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10552   bfd_put_32 (obfd, BLR, p),                    p += 4;
10553
10554   return p;
10555 }
10556
10557 static Elf_Internal_Rela *
10558 get_relocs (asection *sec, int count)
10559 {
10560   Elf_Internal_Rela *relocs;
10561   struct bfd_elf_section_data *elfsec_data;
10562
10563   elfsec_data = elf_section_data (sec);
10564   relocs = elfsec_data->relocs;
10565   if (relocs == NULL)
10566     {
10567       bfd_size_type relsize;
10568       relsize = sec->reloc_count * sizeof (*relocs);
10569       relocs = bfd_alloc (sec->owner, relsize);
10570       if (relocs == NULL)
10571         return NULL;
10572       elfsec_data->relocs = relocs;
10573       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10574                                           sizeof (Elf_Internal_Shdr));
10575       if (elfsec_data->rela.hdr == NULL)
10576         return NULL;
10577       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10578                                         * sizeof (Elf64_External_Rela));
10579       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10580       sec->reloc_count = 0;
10581     }
10582   relocs += sec->reloc_count;
10583   sec->reloc_count += count;
10584   return relocs;
10585 }
10586
10587 static bfd_vma
10588 get_r2off (struct bfd_link_info *info,
10589            struct ppc_stub_hash_entry *stub_entry)
10590 {
10591   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10592   bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10593
10594   if (r2off == 0)
10595     {
10596       /* Support linking -R objects.  Get the toc pointer from the
10597          opd entry.  */
10598       char buf[8];
10599       if (!htab->opd_abi)
10600         return r2off;
10601       asection *opd = stub_entry->h->elf.root.u.def.section;
10602       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10603
10604       if (strcmp (opd->name, ".opd") != 0
10605           || opd->reloc_count != 0)
10606         {
10607           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10608                                   stub_entry->h->elf.root.root.string);
10609           bfd_set_error (bfd_error_bad_value);
10610           return (bfd_vma) -1;
10611         }
10612       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10613         return (bfd_vma) -1;
10614       r2off = bfd_get_64 (opd->owner, buf);
10615       r2off -= elf_gp (info->output_bfd);
10616     }
10617   r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10618   return r2off;
10619 }
10620
10621 static bfd_boolean
10622 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10623 {
10624   struct ppc_stub_hash_entry *stub_entry;
10625   struct ppc_branch_hash_entry *br_entry;
10626   struct bfd_link_info *info;
10627   struct ppc_link_hash_table *htab;
10628   bfd_byte *loc;
10629   bfd_byte *p;
10630   bfd_vma dest, off;
10631   int size;
10632   Elf_Internal_Rela *r;
10633   asection *plt;
10634
10635   /* Massage our args to the form they really have.  */
10636   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10637   info = in_arg;
10638
10639   htab = ppc_hash_table (info);
10640   if (htab == NULL)
10641     return FALSE;
10642
10643   /* Make a note of the offset within the stubs for this entry.  */
10644   stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10645   loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10646
10647   htab->stub_count[stub_entry->stub_type - 1] += 1;
10648   switch (stub_entry->stub_type)
10649     {
10650     case ppc_stub_long_branch:
10651     case ppc_stub_long_branch_r2off:
10652       /* Branches are relative.  This is where we are going to.  */
10653       dest = (stub_entry->target_value
10654               + stub_entry->target_section->output_offset
10655               + stub_entry->target_section->output_section->vma);
10656       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10657       off = dest;
10658
10659       /* And this is where we are coming from.  */
10660       off -= (stub_entry->stub_offset
10661               + stub_entry->group->stub_sec->output_offset
10662               + stub_entry->group->stub_sec->output_section->vma);
10663
10664       size = 4;
10665       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10666         {
10667           bfd_vma r2off = get_r2off (info, stub_entry);
10668
10669           if (r2off == (bfd_vma) -1)
10670             {
10671               htab->stub_error = TRUE;
10672               return FALSE;
10673             }
10674           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10675           loc += 4;
10676           size = 8;
10677           if (PPC_HA (r2off) != 0)
10678             {
10679               bfd_put_32 (htab->params->stub_bfd,
10680                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10681               loc += 4;
10682               size += 4;
10683             }
10684           if (PPC_LO (r2off) != 0)
10685             {
10686               bfd_put_32 (htab->params->stub_bfd,
10687                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10688               loc += 4;
10689               size += 4;
10690             }
10691           off -= size - 4;
10692         }
10693       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10694
10695       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10696         {
10697           info->callbacks->einfo
10698             (_("%P: long branch stub `%s' offset overflow\n"),
10699              stub_entry->root.string);
10700           htab->stub_error = TRUE;
10701           return FALSE;
10702         }
10703
10704       if (info->emitrelocations)
10705         {
10706           r = get_relocs (stub_entry->group->stub_sec, 1);
10707           if (r == NULL)
10708             return FALSE;
10709           r->r_offset = loc - stub_entry->group->stub_sec->contents;
10710           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10711           r->r_addend = dest;
10712           if (stub_entry->h != NULL)
10713             {
10714               struct elf_link_hash_entry **hashes;
10715               unsigned long symndx;
10716               struct ppc_link_hash_entry *h;
10717
10718               hashes = elf_sym_hashes (htab->params->stub_bfd);
10719               if (hashes == NULL)
10720                 {
10721                   bfd_size_type hsize;
10722
10723                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10724                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10725                   if (hashes == NULL)
10726                     return FALSE;
10727                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10728                   htab->stub_globals = 1;
10729                 }
10730               symndx = htab->stub_globals++;
10731               h = stub_entry->h;
10732               hashes[symndx] = &h->elf;
10733               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10734               if (h->oh != NULL && h->oh->is_func)
10735                 h = ppc_follow_link (h->oh);
10736               if (h->elf.root.u.def.section != stub_entry->target_section)
10737                 /* H is an opd symbol.  The addend must be zero.  */
10738                 r->r_addend = 0;
10739               else
10740                 {
10741                   off = (h->elf.root.u.def.value
10742                          + h->elf.root.u.def.section->output_offset
10743                          + h->elf.root.u.def.section->output_section->vma);
10744                   r->r_addend -= off;
10745                 }
10746             }
10747         }
10748       break;
10749
10750     case ppc_stub_plt_branch:
10751     case ppc_stub_plt_branch_r2off:
10752       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10753                                          stub_entry->root.string + 9,
10754                                          FALSE, FALSE);
10755       if (br_entry == NULL)
10756         {
10757           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10758                                   stub_entry->root.string);
10759           htab->stub_error = TRUE;
10760           return FALSE;
10761         }
10762
10763       dest = (stub_entry->target_value
10764               + stub_entry->target_section->output_offset
10765               + stub_entry->target_section->output_section->vma);
10766       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10767         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10768
10769       bfd_put_64 (htab->brlt->owner, dest,
10770                   htab->brlt->contents + br_entry->offset);
10771
10772       if (br_entry->iter == htab->stub_iteration)
10773         {
10774           br_entry->iter = 0;
10775
10776           if (htab->relbrlt != NULL)
10777             {
10778               /* Create a reloc for the branch lookup table entry.  */
10779               Elf_Internal_Rela rela;
10780               bfd_byte *rl;
10781
10782               rela.r_offset = (br_entry->offset
10783                                + htab->brlt->output_offset
10784                                + htab->brlt->output_section->vma);
10785               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10786               rela.r_addend = dest;
10787
10788               rl = htab->relbrlt->contents;
10789               rl += (htab->relbrlt->reloc_count++
10790                      * sizeof (Elf64_External_Rela));
10791               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10792             }
10793           else if (info->emitrelocations)
10794             {
10795               r = get_relocs (htab->brlt, 1);
10796               if (r == NULL)
10797                 return FALSE;
10798               /* brlt, being SEC_LINKER_CREATED does not go through the
10799                  normal reloc processing.  Symbols and offsets are not
10800                  translated from input file to output file form, so
10801                  set up the offset per the output file.  */
10802               r->r_offset = (br_entry->offset
10803                              + htab->brlt->output_offset
10804                              + htab->brlt->output_section->vma);
10805               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10806               r->r_addend = dest;
10807             }
10808         }
10809
10810       dest = (br_entry->offset
10811               + htab->brlt->output_offset
10812               + htab->brlt->output_section->vma);
10813
10814       off = (dest
10815              - elf_gp (htab->brlt->output_section->owner)
10816              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10817
10818       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10819         {
10820           info->callbacks->einfo
10821             (_("%P: linkage table error against `%T'\n"),
10822              stub_entry->root.string);
10823           bfd_set_error (bfd_error_bad_value);
10824           htab->stub_error = TRUE;
10825           return FALSE;
10826         }
10827
10828       if (info->emitrelocations)
10829         {
10830           r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10831           if (r == NULL)
10832             return FALSE;
10833           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10834           if (bfd_big_endian (info->output_bfd))
10835             r[0].r_offset += 2;
10836           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10837             r[0].r_offset += 4;
10838           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10839           r[0].r_addend = dest;
10840           if (PPC_HA (off) != 0)
10841             {
10842               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10843               r[1].r_offset = r[0].r_offset + 4;
10844               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10845               r[1].r_addend = r[0].r_addend;
10846             }
10847         }
10848
10849       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10850         {
10851           if (PPC_HA (off) != 0)
10852             {
10853               size = 16;
10854               bfd_put_32 (htab->params->stub_bfd,
10855                           ADDIS_R12_R2 | PPC_HA (off), loc);
10856               loc += 4;
10857               bfd_put_32 (htab->params->stub_bfd,
10858                           LD_R12_0R12 | PPC_LO (off), loc);
10859             }
10860           else
10861             {
10862               size = 12;
10863               bfd_put_32 (htab->params->stub_bfd,
10864                           LD_R12_0R2 | PPC_LO (off), loc);
10865             }
10866         }
10867       else
10868         {
10869           bfd_vma r2off = get_r2off (info, stub_entry);
10870
10871           if (r2off == (bfd_vma) -1)
10872             {
10873               htab->stub_error = TRUE;
10874               return FALSE;
10875             }
10876
10877           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10878           loc += 4;
10879           size = 16;
10880           if (PPC_HA (off) != 0)
10881             {
10882               size += 4;
10883               bfd_put_32 (htab->params->stub_bfd,
10884                           ADDIS_R12_R2 | PPC_HA (off), loc);
10885               loc += 4;
10886               bfd_put_32 (htab->params->stub_bfd,
10887                           LD_R12_0R12 | PPC_LO (off), loc);
10888             }
10889           else
10890             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10891
10892           if (PPC_HA (r2off) != 0)
10893             {
10894               size += 4;
10895               loc += 4;
10896               bfd_put_32 (htab->params->stub_bfd,
10897                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10898             }
10899           if (PPC_LO (r2off) != 0)
10900             {
10901               size += 4;
10902               loc += 4;
10903               bfd_put_32 (htab->params->stub_bfd,
10904                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10905             }
10906         }
10907       loc += 4;
10908       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10909       loc += 4;
10910       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10911       break;
10912
10913     case ppc_stub_plt_call:
10914     case ppc_stub_plt_call_r2save:
10915       if (stub_entry->h != NULL
10916           && stub_entry->h->is_func_descriptor
10917           && stub_entry->h->oh != NULL)
10918         {
10919           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10920
10921           /* If the old-ABI "dot-symbol" is undefined make it weak so
10922              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.  */
10923           if (fh->elf.root.type == bfd_link_hash_undefined)
10924             fh->elf.root.type = bfd_link_hash_undefweak;
10925           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10926           fh->was_undefined = 0;
10927         }
10928
10929       /* Now build the stub.  */
10930       dest = stub_entry->plt_ent->plt.offset & ~1;
10931       if (dest >= (bfd_vma) -2)
10932         abort ();
10933
10934       plt = htab->elf.splt;
10935       if (!htab->elf.dynamic_sections_created
10936           || stub_entry->h == NULL
10937           || stub_entry->h->elf.dynindx == -1)
10938         plt = htab->elf.iplt;
10939
10940       dest += plt->output_offset + plt->output_section->vma;
10941
10942       if (stub_entry->h == NULL
10943           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10944         {
10945           Elf_Internal_Rela rela;
10946           bfd_byte *rl;
10947
10948           rela.r_offset = dest;
10949           if (htab->opd_abi)
10950             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10951           else
10952             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10953           rela.r_addend = (stub_entry->target_value
10954                            + stub_entry->target_section->output_offset
10955                            + stub_entry->target_section->output_section->vma);
10956
10957           rl = (htab->elf.irelplt->contents
10958                 + (htab->elf.irelplt->reloc_count++
10959                    * sizeof (Elf64_External_Rela)));
10960           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10961           stub_entry->plt_ent->plt.offset |= 1;
10962         }
10963
10964       off = (dest
10965              - elf_gp (plt->output_section->owner)
10966              - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10967
10968       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10969         {
10970           info->callbacks->einfo
10971             (_("%P: linkage table error against `%T'\n"),
10972              stub_entry->h != NULL
10973              ? stub_entry->h->elf.root.root.string
10974              : "<local sym>");
10975           bfd_set_error (bfd_error_bad_value);
10976           htab->stub_error = TRUE;
10977           return FALSE;
10978         }
10979
10980       if (htab->params->plt_stub_align != 0)
10981         {
10982           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10983
10984           stub_entry->group->stub_sec->size += pad;
10985           stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10986           loc += pad;
10987         }
10988
10989       r = NULL;
10990       if (info->emitrelocations)
10991         {
10992           r = get_relocs (stub_entry->group->stub_sec,
10993                           ((PPC_HA (off) != 0)
10994                            + (htab->opd_abi
10995                               ? 2 + (htab->params->plt_static_chain
10996                                      && PPC_HA (off + 16) == PPC_HA (off))
10997                               : 1)));
10998           if (r == NULL)
10999             return FALSE;
11000           r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11001           if (bfd_big_endian (info->output_bfd))
11002             r[0].r_offset += 2;
11003           r[0].r_addend = dest;
11004         }
11005       if (stub_entry->h != NULL
11006           && (stub_entry->h == htab->tls_get_addr_fd
11007               || stub_entry->h == htab->tls_get_addr)
11008           && htab->params->tls_get_addr_opt)
11009         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11010       else
11011         p = build_plt_stub (htab, stub_entry, loc, off, r);
11012       size = p - loc;
11013       break;
11014
11015     case ppc_stub_save_res:
11016       return TRUE;
11017
11018     default:
11019       BFD_FAIL ();
11020       return FALSE;
11021     }
11022
11023   stub_entry->group->stub_sec->size += size;
11024
11025   if (htab->params->emit_stub_syms)
11026     {
11027       struct elf_link_hash_entry *h;
11028       size_t len1, len2;
11029       char *name;
11030       const char *const stub_str[] = { "long_branch",
11031                                        "long_branch_r2off",
11032                                        "plt_branch",
11033                                        "plt_branch_r2off",
11034                                        "plt_call",
11035                                        "plt_call" };
11036
11037       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11038       len2 = strlen (stub_entry->root.string);
11039       name = bfd_malloc (len1 + len2 + 2);
11040       if (name == NULL)
11041         return FALSE;
11042       memcpy (name, stub_entry->root.string, 9);
11043       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11044       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11045       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11046       if (h == NULL)
11047         return FALSE;
11048       if (h->root.type == bfd_link_hash_new)
11049         {
11050           h->root.type = bfd_link_hash_defined;
11051           h->root.u.def.section = stub_entry->group->stub_sec;
11052           h->root.u.def.value = stub_entry->stub_offset;
11053           h->ref_regular = 1;
11054           h->def_regular = 1;
11055           h->ref_regular_nonweak = 1;
11056           h->forced_local = 1;
11057           h->non_elf = 0;
11058           h->root.linker_def = 1;
11059         }
11060     }
11061
11062   return TRUE;
11063 }
11064
11065 /* As above, but don't actually build the stub.  Just bump offset so
11066    we know stub section sizes, and select plt_branch stubs where
11067    long_branch stubs won't do.  */
11068
11069 static bfd_boolean
11070 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11071 {
11072   struct ppc_stub_hash_entry *stub_entry;
11073   struct bfd_link_info *info;
11074   struct ppc_link_hash_table *htab;
11075   bfd_vma off;
11076   int size;
11077
11078   /* Massage our args to the form they really have.  */
11079   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11080   info = in_arg;
11081
11082   htab = ppc_hash_table (info);
11083   if (htab == NULL)
11084     return FALSE;
11085
11086   if (stub_entry->h != NULL
11087       && stub_entry->h->save_res
11088       && stub_entry->h->elf.root.type == bfd_link_hash_defined
11089       && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11090     {
11091       /* Don't make stubs to out-of-line register save/restore
11092          functions.  Instead, emit copies of the functions.  */
11093       stub_entry->group->needs_save_res = 1;
11094       stub_entry->stub_type = ppc_stub_save_res;
11095       return TRUE;
11096     }
11097
11098   if (stub_entry->stub_type == ppc_stub_plt_call
11099       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11100     {
11101       asection *plt;
11102       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11103       if (off >= (bfd_vma) -2)
11104         abort ();
11105       plt = htab->elf.splt;
11106       if (!htab->elf.dynamic_sections_created
11107           || stub_entry->h == NULL
11108           || stub_entry->h->elf.dynindx == -1)
11109         plt = htab->elf.iplt;
11110       off += (plt->output_offset
11111               + plt->output_section->vma
11112               - elf_gp (plt->output_section->owner)
11113               - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11114
11115       size = plt_stub_size (htab, stub_entry, off);
11116       if (htab->params->plt_stub_align)
11117         size += plt_stub_pad (htab, stub_entry, off);
11118       if (info->emitrelocations)
11119         {
11120           stub_entry->group->stub_sec->reloc_count
11121             += ((PPC_HA (off) != 0)
11122                 + (htab->opd_abi
11123                    ? 2 + (htab->params->plt_static_chain
11124                           && PPC_HA (off + 16) == PPC_HA (off))
11125                    : 1));
11126           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11127         }
11128     }
11129   else
11130     {
11131       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11132          variants.  */
11133       bfd_vma r2off = 0;
11134       bfd_vma local_off = 0;
11135
11136       off = (stub_entry->target_value
11137              + stub_entry->target_section->output_offset
11138              + stub_entry->target_section->output_section->vma);
11139       off -= (stub_entry->group->stub_sec->size
11140               + stub_entry->group->stub_sec->output_offset
11141               + stub_entry->group->stub_sec->output_section->vma);
11142
11143       /* Reset the stub type from the plt variant in case we now
11144          can reach with a shorter stub.  */
11145       if (stub_entry->stub_type >= ppc_stub_plt_branch)
11146         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11147
11148       size = 4;
11149       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11150         {
11151           r2off = get_r2off (info, stub_entry);
11152           if (r2off == (bfd_vma) -1)
11153             {
11154               htab->stub_error = TRUE;
11155               return FALSE;
11156             }
11157           size = 8;
11158           if (PPC_HA (r2off) != 0)
11159             size += 4;
11160           if (PPC_LO (r2off) != 0)
11161             size += 4;
11162           off -= size - 4;
11163         }
11164
11165       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11166
11167       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11168          Do the same for -R objects without function descriptors.  */
11169       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11170           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11171               && r2off == 0
11172               && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11173         {
11174           struct ppc_branch_hash_entry *br_entry;
11175
11176           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11177                                              stub_entry->root.string + 9,
11178                                              TRUE, FALSE);
11179           if (br_entry == NULL)
11180             {
11181               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11182                                       stub_entry->root.string);
11183               htab->stub_error = TRUE;
11184               return FALSE;
11185             }
11186
11187           if (br_entry->iter != htab->stub_iteration)
11188             {
11189               br_entry->iter = htab->stub_iteration;
11190               br_entry->offset = htab->brlt->size;
11191               htab->brlt->size += 8;
11192
11193               if (htab->relbrlt != NULL)
11194                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11195               else if (info->emitrelocations)
11196                 {
11197                   htab->brlt->reloc_count += 1;
11198                   htab->brlt->flags |= SEC_RELOC;
11199                 }
11200             }
11201
11202           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11203           off = (br_entry->offset
11204                  + htab->brlt->output_offset
11205                  + htab->brlt->output_section->vma
11206                  - elf_gp (htab->brlt->output_section->owner)
11207                  - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11208
11209           if (info->emitrelocations)
11210             {
11211               stub_entry->group->stub_sec->reloc_count
11212                 += 1 + (PPC_HA (off) != 0);
11213               stub_entry->group->stub_sec->flags |= SEC_RELOC;
11214             }
11215
11216           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11217             {
11218               size = 12;
11219               if (PPC_HA (off) != 0)
11220                 size = 16;
11221             }
11222           else
11223             {
11224               size = 16;
11225               if (PPC_HA (off) != 0)
11226                 size += 4;
11227
11228               if (PPC_HA (r2off) != 0)
11229                 size += 4;
11230               if (PPC_LO (r2off) != 0)
11231                 size += 4;
11232             }
11233         }
11234       else if (info->emitrelocations)
11235         {
11236           stub_entry->group->stub_sec->reloc_count += 1;
11237           stub_entry->group->stub_sec->flags |= SEC_RELOC;
11238         }
11239     }
11240
11241   stub_entry->group->stub_sec->size += size;
11242   return TRUE;
11243 }
11244
11245 /* Set up various things so that we can make a list of input sections
11246    for each output section included in the link.  Returns -1 on error,
11247    0 when no stubs will be needed, and 1 on success.  */
11248
11249 int
11250 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11251 {
11252   unsigned int id;
11253   bfd_size_type amt;
11254   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11255
11256   if (htab == NULL)
11257     return -1;
11258
11259   htab->sec_info_arr_size = bfd_get_next_section_id ();
11260   amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11261   htab->sec_info = bfd_zmalloc (amt);
11262   if (htab->sec_info == NULL)
11263     return -1;
11264
11265   /* Set toc_off for com, und, abs and ind sections.  */
11266   for (id = 0; id < 3; id++)
11267     htab->sec_info[id].toc_off = TOC_BASE_OFF;
11268
11269   return 1;
11270 }
11271
11272 /* Set up for first pass at multitoc partitioning.  */
11273
11274 void
11275 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11276 {
11277   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11278
11279   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11280   htab->toc_bfd = NULL;
11281   htab->toc_first_sec = NULL;
11282 }
11283
11284 /* The linker repeatedly calls this function for each TOC input section
11285    and linker generated GOT section.  Group input bfds such that the toc
11286    within a group is less than 64k in size.  */
11287
11288 bfd_boolean
11289 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11290 {
11291   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11292   bfd_vma addr, off, limit;
11293
11294   if (htab == NULL)
11295     return FALSE;
11296
11297   if (!htab->second_toc_pass)
11298     {
11299       /* Keep track of the first .toc or .got section for this input bfd.  */
11300       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11301
11302       if (new_bfd)
11303         {
11304           htab->toc_bfd = isec->owner;
11305           htab->toc_first_sec = isec;
11306         }
11307
11308       addr = isec->output_offset + isec->output_section->vma;
11309       off = addr - htab->toc_curr;
11310       limit = 0x80008000;
11311       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11312         limit = 0x10000;
11313       if (off + isec->size > limit)
11314         {
11315           addr = (htab->toc_first_sec->output_offset
11316                   + htab->toc_first_sec->output_section->vma);
11317           htab->toc_curr = addr;
11318           htab->toc_curr &= -TOC_BASE_ALIGN;
11319         }
11320
11321       /* toc_curr is the base address of this toc group.  Set elf_gp
11322          for the input section to be the offset relative to the
11323          output toc base plus 0x8000.  Making the input elf_gp an
11324          offset allows us to move the toc as a whole without
11325          recalculating input elf_gp.  */
11326       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11327       off += TOC_BASE_OFF;
11328
11329       /* Die if someone uses a linker script that doesn't keep input
11330          file .toc and .got together.  */
11331       if (new_bfd
11332           && elf_gp (isec->owner) != 0
11333           && elf_gp (isec->owner) != off)
11334         return FALSE;
11335
11336       elf_gp (isec->owner) = off;
11337       return TRUE;
11338     }
11339
11340   /* During the second pass toc_first_sec points to the start of
11341      a toc group, and toc_curr is used to track the old elf_gp.
11342      We use toc_bfd to ensure we only look at each bfd once.  */
11343   if (htab->toc_bfd == isec->owner)
11344     return TRUE;
11345   htab->toc_bfd = isec->owner;
11346
11347   if (htab->toc_first_sec == NULL
11348       || htab->toc_curr != elf_gp (isec->owner))
11349     {
11350       htab->toc_curr = elf_gp (isec->owner);
11351       htab->toc_first_sec = isec;
11352     }
11353   addr = (htab->toc_first_sec->output_offset
11354           + htab->toc_first_sec->output_section->vma);
11355   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11356   elf_gp (isec->owner) = off;
11357
11358   return TRUE;
11359 }
11360
11361 /* Called via elf_link_hash_traverse to merge GOT entries for global
11362    symbol H.  */
11363
11364 static bfd_boolean
11365 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11366 {
11367   if (h->root.type == bfd_link_hash_indirect)
11368     return TRUE;
11369
11370   merge_got_entries (&h->got.glist);
11371
11372   return TRUE;
11373 }
11374
11375 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11376    symbol H.  */
11377
11378 static bfd_boolean
11379 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11380 {
11381   struct got_entry *gent;
11382
11383   if (h->root.type == bfd_link_hash_indirect)
11384     return TRUE;
11385
11386   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11387     if (!gent->is_indirect)
11388       allocate_got (h, (struct bfd_link_info *) inf, gent);
11389   return TRUE;
11390 }
11391
11392 /* Called on the first multitoc pass after the last call to
11393    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11394    entries.  */
11395
11396 bfd_boolean
11397 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11398 {
11399   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11400   struct bfd *ibfd, *ibfd2;
11401   bfd_boolean done_something;
11402
11403   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11404
11405   if (!htab->do_multi_toc)
11406     return FALSE;
11407
11408   /* Merge global sym got entries within a toc group.  */
11409   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11410
11411   /* And tlsld_got.  */
11412   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11413     {
11414       struct got_entry *ent, *ent2;
11415
11416       if (!is_ppc64_elf (ibfd))
11417         continue;
11418
11419       ent = ppc64_tlsld_got (ibfd);
11420       if (!ent->is_indirect
11421           && ent->got.offset != (bfd_vma) -1)
11422         {
11423           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11424             {
11425               if (!is_ppc64_elf (ibfd2))
11426                 continue;
11427
11428               ent2 = ppc64_tlsld_got (ibfd2);
11429               if (!ent2->is_indirect
11430                   && ent2->got.offset != (bfd_vma) -1
11431                   && elf_gp (ibfd2) == elf_gp (ibfd))
11432                 {
11433                   ent2->is_indirect = TRUE;
11434                   ent2->got.ent = ent;
11435                 }
11436             }
11437         }
11438     }
11439
11440   /* Zap sizes of got sections.  */
11441   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11442   htab->elf.irelplt->size -= htab->got_reli_size;
11443   htab->got_reli_size = 0;
11444
11445   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11446     {
11447       asection *got, *relgot;
11448
11449       if (!is_ppc64_elf (ibfd))
11450         continue;
11451
11452       got = ppc64_elf_tdata (ibfd)->got;
11453       if (got != NULL)
11454         {
11455           got->rawsize = got->size;
11456           got->size = 0;
11457           relgot = ppc64_elf_tdata (ibfd)->relgot;
11458           relgot->rawsize = relgot->size;
11459           relgot->size = 0;
11460         }
11461     }
11462
11463   /* Now reallocate the got, local syms first.  We don't need to
11464      allocate section contents again since we never increase size.  */
11465   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11466     {
11467       struct got_entry **lgot_ents;
11468       struct got_entry **end_lgot_ents;
11469       struct plt_entry **local_plt;
11470       struct plt_entry **end_local_plt;
11471       unsigned char *lgot_masks;
11472       bfd_size_type locsymcount;
11473       Elf_Internal_Shdr *symtab_hdr;
11474       asection *s;
11475
11476       if (!is_ppc64_elf (ibfd))
11477         continue;
11478
11479       lgot_ents = elf_local_got_ents (ibfd);
11480       if (!lgot_ents)
11481         continue;
11482
11483       symtab_hdr = &elf_symtab_hdr (ibfd);
11484       locsymcount = symtab_hdr->sh_info;
11485       end_lgot_ents = lgot_ents + locsymcount;
11486       local_plt = (struct plt_entry **) end_lgot_ents;
11487       end_local_plt = local_plt + locsymcount;
11488       lgot_masks = (unsigned char *) end_local_plt;
11489       s = ppc64_elf_tdata (ibfd)->got;
11490       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11491         {
11492           struct got_entry *ent;
11493
11494           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11495             {
11496               unsigned int ent_size = 8;
11497               unsigned int rel_size = sizeof (Elf64_External_Rela);
11498
11499               ent->got.offset = s->size;
11500               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11501                 {
11502                   ent_size *= 2;
11503                   rel_size *= 2;
11504                 }
11505               s->size += ent_size;
11506               if ((*lgot_masks & PLT_IFUNC) != 0)
11507                 {
11508                   htab->elf.irelplt->size += rel_size;
11509                   htab->got_reli_size += rel_size;
11510                 }
11511               else if (bfd_link_pic (info))
11512                 {
11513                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11514                   srel->size += rel_size;
11515                 }
11516             }
11517         }
11518     }
11519
11520   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11521
11522   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11523     {
11524       struct got_entry *ent;
11525
11526       if (!is_ppc64_elf (ibfd))
11527         continue;
11528
11529       ent = ppc64_tlsld_got (ibfd);
11530       if (!ent->is_indirect
11531           && ent->got.offset != (bfd_vma) -1)
11532         {
11533           asection *s = ppc64_elf_tdata (ibfd)->got;
11534           ent->got.offset = s->size;
11535           s->size += 16;
11536           if (bfd_link_pic (info))
11537             {
11538               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11539               srel->size += sizeof (Elf64_External_Rela);
11540             }
11541         }
11542     }
11543
11544   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11545   if (!done_something)
11546     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11547       {
11548         asection *got;
11549
11550         if (!is_ppc64_elf (ibfd))
11551           continue;
11552
11553         got = ppc64_elf_tdata (ibfd)->got;
11554         if (got != NULL)
11555           {
11556             done_something = got->rawsize != got->size;
11557             if (done_something)
11558               break;
11559           }
11560       }
11561
11562   if (done_something)
11563     (*htab->params->layout_sections_again) ();
11564
11565   /* Set up for second pass over toc sections to recalculate elf_gp
11566      on input sections.  */
11567   htab->toc_bfd = NULL;
11568   htab->toc_first_sec = NULL;
11569   htab->second_toc_pass = TRUE;
11570   return done_something;
11571 }
11572
11573 /* Called after second pass of multitoc partitioning.  */
11574
11575 void
11576 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11577 {
11578   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11579
11580   /* After the second pass, toc_curr tracks the TOC offset used
11581      for code sections below in ppc64_elf_next_input_section.  */
11582   htab->toc_curr = TOC_BASE_OFF;
11583 }
11584
11585 /* No toc references were found in ISEC.  If the code in ISEC makes no
11586    calls, then there's no need to use toc adjusting stubs when branching
11587    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11588    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11589    needed, and 2 if a cyclical call-graph was found but no other reason
11590    for a stub was detected.  If called from the top level, a return of
11591    2 means the same as a return of 0.  */
11592
11593 static int
11594 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11595 {
11596   int ret;
11597
11598   /* Mark this section as checked.  */
11599   isec->call_check_done = 1;
11600
11601   /* We know none of our code bearing sections will need toc stubs.  */
11602   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11603     return 0;
11604
11605   if (isec->size == 0)
11606     return 0;
11607
11608   if (isec->output_section == NULL)
11609     return 0;
11610
11611   ret = 0;
11612   if (isec->reloc_count != 0)
11613     {
11614       Elf_Internal_Rela *relstart, *rel;
11615       Elf_Internal_Sym *local_syms;
11616       struct ppc_link_hash_table *htab;
11617
11618       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11619                                             info->keep_memory);
11620       if (relstart == NULL)
11621         return -1;
11622
11623       /* Look for branches to outside of this section.  */
11624       local_syms = NULL;
11625       htab = ppc_hash_table (info);
11626       if (htab == NULL)
11627         return -1;
11628
11629       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11630         {
11631           enum elf_ppc64_reloc_type r_type;
11632           unsigned long r_symndx;
11633           struct elf_link_hash_entry *h;
11634           struct ppc_link_hash_entry *eh;
11635           Elf_Internal_Sym *sym;
11636           asection *sym_sec;
11637           struct _opd_sec_data *opd;
11638           bfd_vma sym_value;
11639           bfd_vma dest;
11640
11641           r_type = ELF64_R_TYPE (rel->r_info);
11642           if (r_type != R_PPC64_REL24
11643               && r_type != R_PPC64_REL14
11644               && r_type != R_PPC64_REL14_BRTAKEN
11645               && r_type != R_PPC64_REL14_BRNTAKEN)
11646             continue;
11647
11648           r_symndx = ELF64_R_SYM (rel->r_info);
11649           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11650                           isec->owner))
11651             {
11652               ret = -1;
11653               break;
11654             }
11655
11656           /* Calls to dynamic lib functions go through a plt call stub
11657              that uses r2.  */
11658           eh = (struct ppc_link_hash_entry *) h;
11659           if (eh != NULL
11660               && (eh->elf.plt.plist != NULL
11661                   || (eh->oh != NULL
11662                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11663             {
11664               ret = 1;
11665               break;
11666             }
11667
11668           if (sym_sec == NULL)
11669             /* Ignore other undefined symbols.  */
11670             continue;
11671
11672           /* Assume branches to other sections not included in the
11673              link need stubs too, to cover -R and absolute syms.  */
11674           if (sym_sec->output_section == NULL)
11675             {
11676               ret = 1;
11677               break;
11678             }
11679
11680           if (h == NULL)
11681             sym_value = sym->st_value;
11682           else
11683             {
11684               if (h->root.type != bfd_link_hash_defined
11685                   && h->root.type != bfd_link_hash_defweak)
11686                 abort ();
11687               sym_value = h->root.u.def.value;
11688             }
11689           sym_value += rel->r_addend;
11690
11691           /* If this branch reloc uses an opd sym, find the code section.  */
11692           opd = get_opd_info (sym_sec);
11693           if (opd != NULL)
11694             {
11695               if (h == NULL && opd->adjust != NULL)
11696                 {
11697                   long adjust;
11698
11699                   adjust = opd->adjust[OPD_NDX (sym_value)];
11700                   if (adjust == -1)
11701                     /* Assume deleted functions won't ever be called.  */
11702                     continue;
11703                   sym_value += adjust;
11704                 }
11705
11706               dest = opd_entry_value (sym_sec, sym_value,
11707                                       &sym_sec, NULL, FALSE);
11708               if (dest == (bfd_vma) -1)
11709                 continue;
11710             }
11711           else
11712             dest = (sym_value
11713                     + sym_sec->output_offset
11714                     + sym_sec->output_section->vma);
11715
11716           /* Ignore branch to self.  */
11717           if (sym_sec == isec)
11718             continue;
11719
11720           /* If the called function uses the toc, we need a stub.  */
11721           if (sym_sec->has_toc_reloc
11722               || sym_sec->makes_toc_func_call)
11723             {
11724               ret = 1;
11725               break;
11726             }
11727
11728           /* Assume any branch that needs a long branch stub might in fact
11729              need a plt_branch stub.  A plt_branch stub uses r2.  */
11730           else if (dest - (isec->output_offset
11731                            + isec->output_section->vma
11732                            + rel->r_offset) + (1 << 25)
11733                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11734                                                              ? h->other
11735                                                              : sym->st_other))
11736             {
11737               ret = 1;
11738               break;
11739             }
11740
11741           /* If calling back to a section in the process of being
11742              tested, we can't say for sure that no toc adjusting stubs
11743              are needed, so don't return zero.  */
11744           else if (sym_sec->call_check_in_progress)
11745             ret = 2;
11746
11747           /* Branches to another section that itself doesn't have any TOC
11748              references are OK.  Recursively call ourselves to check.  */
11749           else if (!sym_sec->call_check_done)
11750             {
11751               int recur;
11752
11753               /* Mark current section as indeterminate, so that other
11754                  sections that call back to current won't be marked as
11755                  known.  */
11756               isec->call_check_in_progress = 1;
11757               recur = toc_adjusting_stub_needed (info, sym_sec);
11758               isec->call_check_in_progress = 0;
11759
11760               if (recur != 0)
11761                 {
11762                   ret = recur;
11763                   if (recur != 2)
11764                     break;
11765                 }
11766             }
11767         }
11768
11769       if (local_syms != NULL
11770           && (elf_symtab_hdr (isec->owner).contents
11771               != (unsigned char *) local_syms))
11772         free (local_syms);
11773       if (elf_section_data (isec)->relocs != relstart)
11774         free (relstart);
11775     }
11776
11777   if ((ret & 1) == 0
11778       && isec->map_head.s != NULL
11779       && (strcmp (isec->output_section->name, ".init") == 0
11780           || strcmp (isec->output_section->name, ".fini") == 0))
11781     {
11782       if (isec->map_head.s->has_toc_reloc
11783           || isec->map_head.s->makes_toc_func_call)
11784         ret = 1;
11785       else if (!isec->map_head.s->call_check_done)
11786         {
11787           int recur;
11788           isec->call_check_in_progress = 1;
11789           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11790           isec->call_check_in_progress = 0;
11791           if (recur != 0)
11792             ret = recur;
11793         }
11794     }
11795
11796   if (ret == 1)
11797     isec->makes_toc_func_call = 1;
11798
11799   return ret;
11800 }
11801
11802 /* The linker repeatedly calls this function for each input section,
11803    in the order that input sections are linked into output sections.
11804    Build lists of input sections to determine groupings between which
11805    we may insert linker stubs.  */
11806
11807 bfd_boolean
11808 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11809 {
11810   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11811
11812   if (htab == NULL)
11813     return FALSE;
11814
11815   if ((isec->output_section->flags & SEC_CODE) != 0
11816       && isec->output_section->id < htab->sec_info_arr_size)
11817     {
11818       /* This happens to make the list in reverse order,
11819          which is what we want.  */
11820       htab->sec_info[isec->id].u.list
11821         = htab->sec_info[isec->output_section->id].u.list;
11822       htab->sec_info[isec->output_section->id].u.list = isec;
11823     }
11824
11825   if (htab->multi_toc_needed)
11826     {
11827       /* Analyse sections that aren't already flagged as needing a
11828          valid toc pointer.  Exclude .fixup for the linux kernel.
11829          .fixup contains branches, but only back to the function that
11830          hit an exception.  */
11831       if (!(isec->has_toc_reloc
11832             || (isec->flags & SEC_CODE) == 0
11833             || strcmp (isec->name, ".fixup") == 0
11834             || isec->call_check_done))
11835         {
11836           if (toc_adjusting_stub_needed (info, isec) < 0)
11837             return FALSE;
11838         }
11839       /* Make all sections use the TOC assigned for this object file.
11840          This will be wrong for pasted sections;  We fix that in
11841          check_pasted_section().  */
11842       if (elf_gp (isec->owner) != 0)
11843         htab->toc_curr = elf_gp (isec->owner);
11844     }
11845
11846   htab->sec_info[isec->id].toc_off = htab->toc_curr;
11847   return TRUE;
11848 }
11849
11850 /* Check that all .init and .fini sections use the same toc, if they
11851    have toc relocs.  */
11852
11853 static bfd_boolean
11854 check_pasted_section (struct bfd_link_info *info, const char *name)
11855 {
11856   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11857
11858   if (o != NULL)
11859     {
11860       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11861       bfd_vma toc_off = 0;
11862       asection *i;
11863
11864       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11865         if (i->has_toc_reloc)
11866           {
11867             if (toc_off == 0)
11868               toc_off = htab->sec_info[i->id].toc_off;
11869             else if (toc_off != htab->sec_info[i->id].toc_off)
11870               return FALSE;
11871           }
11872
11873       if (toc_off == 0)
11874         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11875           if (i->makes_toc_func_call)
11876             {
11877               toc_off = htab->sec_info[i->id].toc_off;
11878               break;
11879             }
11880
11881       /* Make sure the whole pasted function uses the same toc offset.  */
11882       if (toc_off != 0)
11883         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11884           htab->sec_info[i->id].toc_off = toc_off;
11885     }
11886   return TRUE;
11887 }
11888
11889 bfd_boolean
11890 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11891 {
11892   return (check_pasted_section (info, ".init")
11893           & check_pasted_section (info, ".fini"));
11894 }
11895
11896 /* See whether we can group stub sections together.  Grouping stub
11897    sections may result in fewer stubs.  More importantly, we need to
11898    put all .init* and .fini* stubs at the beginning of the .init or
11899    .fini output sections respectively, because glibc splits the
11900    _init and _fini functions into multiple parts.  Putting a stub in
11901    the middle of a function is not a good idea.  */
11902
11903 static bfd_boolean
11904 group_sections (struct bfd_link_info *info,
11905                 bfd_size_type stub_group_size,
11906                 bfd_boolean stubs_always_before_branch)
11907 {
11908   struct ppc_link_hash_table *htab;
11909   asection *osec;
11910   bfd_size_type stub14_group_size;
11911   bfd_boolean suppress_size_errors;
11912
11913   htab = ppc_hash_table (info);
11914   if (htab == NULL)
11915     return FALSE;
11916
11917   suppress_size_errors = FALSE;
11918   stub14_group_size = stub_group_size >> 10;
11919   if (stub_group_size == 1)
11920     {
11921       /* Default values.  */
11922       if (stubs_always_before_branch)
11923         {
11924           stub_group_size = 0x1e00000;
11925           stub14_group_size = 0x7800;
11926         }
11927       else
11928         {
11929           stub_group_size = 0x1c00000;
11930           stub14_group_size = 0x7000;
11931         }
11932       suppress_size_errors = TRUE;
11933     }
11934
11935   for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11936     {
11937       asection *tail;
11938
11939       if (osec->id >= htab->sec_info_arr_size)
11940         continue;
11941
11942       tail = htab->sec_info[osec->id].u.list;
11943       while (tail != NULL)
11944         {
11945           asection *curr;
11946           asection *prev;
11947           bfd_size_type total;
11948           bfd_boolean big_sec;
11949           bfd_vma curr_toc;
11950           struct map_stub *group;
11951
11952           curr = tail;
11953           total = tail->size;
11954           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11955                              && ppc64_elf_section_data (tail)->has_14bit_branch
11956                              ? stub14_group_size : stub_group_size);
11957           if (big_sec && !suppress_size_errors)
11958             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11959                                      tail->owner, tail);
11960           curr_toc = htab->sec_info[tail->id].toc_off;
11961
11962           while ((prev = htab->sec_info[curr->id].u.list) != NULL
11963                  && ((total += curr->output_offset - prev->output_offset)
11964                      < (ppc64_elf_section_data (prev) != NULL
11965                         && ppc64_elf_section_data (prev)->has_14bit_branch
11966                         ? stub14_group_size : stub_group_size))
11967                  && htab->sec_info[prev->id].toc_off == curr_toc)
11968             curr = prev;
11969
11970           /* OK, the size from the start of CURR to the end is less
11971              than stub_group_size and thus can be handled by one stub
11972              section.  (or the tail section is itself larger than
11973              stub_group_size, in which case we may be toast.)  We
11974              should really be keeping track of the total size of stubs
11975              added here, as stubs contribute to the final output
11976              section size.  That's a little tricky, and this way will
11977              only break if stubs added make the total size more than
11978              2^25, ie. for the default stub_group_size, if stubs total
11979              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11980           group = bfd_alloc (curr->owner, sizeof (*group));
11981           if (group == NULL)
11982             return FALSE;
11983           group->link_sec = curr;
11984           group->stub_sec = NULL;
11985           group->needs_save_res = 0;
11986           group->next = htab->group;
11987           htab->group = group;
11988           do
11989             {
11990               prev = htab->sec_info[tail->id].u.list;
11991               /* Set up this stub group.  */
11992               htab->sec_info[tail->id].u.group = group;
11993             }
11994           while (tail != curr && (tail = prev) != NULL);
11995
11996           /* But wait, there's more!  Input sections up to stub_group_size
11997              bytes before the stub section can be handled by it too.
11998              Don't do this if we have a really large section after the
11999              stubs, as adding more stubs increases the chance that
12000              branches may not reach into the stub section.  */
12001           if (!stubs_always_before_branch && !big_sec)
12002             {
12003               total = 0;
12004               while (prev != NULL
12005                      && ((total += tail->output_offset - prev->output_offset)
12006                          < (ppc64_elf_section_data (prev) != NULL
12007                             && ppc64_elf_section_data (prev)->has_14bit_branch
12008                             ? stub14_group_size : stub_group_size))
12009                      && htab->sec_info[prev->id].toc_off == curr_toc)
12010                 {
12011                   tail = prev;
12012                   prev = htab->sec_info[tail->id].u.list;
12013                   htab->sec_info[tail->id].u.group = group;
12014                 }
12015             }
12016           tail = prev;
12017         }
12018     }
12019   return TRUE;
12020 }
12021
12022 static const unsigned char glink_eh_frame_cie[] =
12023 {
12024   0, 0, 0, 16,                          /* length.  */
12025   0, 0, 0, 0,                           /* id.  */
12026   1,                                    /* CIE version.  */
12027   'z', 'R', 0,                          /* Augmentation string.  */
12028   4,                                    /* Code alignment.  */
12029   0x78,                                 /* Data alignment.  */
12030   65,                                   /* RA reg.  */
12031   1,                                    /* Augmentation size.  */
12032   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
12033   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
12034   0, 0, 0, 0
12035 };
12036
12037 /* Stripping output sections is normally done before dynamic section
12038    symbols have been allocated.  This function is called later, and
12039    handles cases like htab->brlt which is mapped to its own output
12040    section.  */
12041
12042 static void
12043 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12044 {
12045   if (isec->size == 0
12046       && isec->output_section->size == 0
12047       && !(isec->output_section->flags & SEC_KEEP)
12048       && !bfd_section_removed_from_list (info->output_bfd,
12049                                          isec->output_section)
12050       && elf_section_data (isec->output_section)->dynindx == 0)
12051     {
12052       isec->output_section->flags |= SEC_EXCLUDE;
12053       bfd_section_list_remove (info->output_bfd, isec->output_section);
12054       info->output_bfd->section_count--;
12055     }
12056 }
12057
12058 /* Determine and set the size of the stub section for a final link.
12059
12060    The basic idea here is to examine all the relocations looking for
12061    PC-relative calls to a target that is unreachable with a "bl"
12062    instruction.  */
12063
12064 bfd_boolean
12065 ppc64_elf_size_stubs (struct bfd_link_info *info)
12066 {
12067   bfd_size_type stub_group_size;
12068   bfd_boolean stubs_always_before_branch;
12069   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12070
12071   if (htab == NULL)
12072     return FALSE;
12073
12074   if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12075     htab->params->plt_thread_safe = 1;
12076   if (!htab->opd_abi)
12077     htab->params->plt_thread_safe = 0;
12078   else if (htab->params->plt_thread_safe == -1)
12079     {
12080       static const char *const thread_starter[] =
12081         {
12082           "pthread_create",
12083           /* libstdc++ */
12084           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12085           /* librt */
12086           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12087           "mq_notify", "create_timer",
12088           /* libanl */
12089           "getaddrinfo_a",
12090           /* libgomp */
12091           "GOMP_parallel",
12092           "GOMP_parallel_start",
12093           "GOMP_parallel_loop_static",
12094           "GOMP_parallel_loop_static_start",
12095           "GOMP_parallel_loop_dynamic",
12096           "GOMP_parallel_loop_dynamic_start",
12097           "GOMP_parallel_loop_guided",
12098           "GOMP_parallel_loop_guided_start",
12099           "GOMP_parallel_loop_runtime",
12100           "GOMP_parallel_loop_runtime_start",
12101           "GOMP_parallel_sections",
12102           "GOMP_parallel_sections_start",
12103           /* libgo */
12104           "__go_go",
12105         };
12106       unsigned i;
12107
12108       for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12109         {
12110           struct elf_link_hash_entry *h;
12111           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12112                                     FALSE, FALSE, TRUE);
12113           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12114           if (htab->params->plt_thread_safe)
12115             break;
12116         }
12117     }
12118   stubs_always_before_branch = htab->params->group_size < 0;
12119   if (htab->params->group_size < 0)
12120     stub_group_size = -htab->params->group_size;
12121   else
12122     stub_group_size = htab->params->group_size;
12123
12124   if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12125     return FALSE;
12126
12127   while (1)
12128     {
12129       bfd *input_bfd;
12130       unsigned int bfd_indx;
12131       struct map_stub *group;
12132       asection *stub_sec;
12133
12134       htab->stub_iteration += 1;
12135
12136       for (input_bfd = info->input_bfds, bfd_indx = 0;
12137            input_bfd != NULL;
12138            input_bfd = input_bfd->link.next, bfd_indx++)
12139         {
12140           Elf_Internal_Shdr *symtab_hdr;
12141           asection *section;
12142           Elf_Internal_Sym *local_syms = NULL;
12143
12144           if (!is_ppc64_elf (input_bfd))
12145             continue;
12146
12147           /* We'll need the symbol table in a second.  */
12148           symtab_hdr = &elf_symtab_hdr (input_bfd);
12149           if (symtab_hdr->sh_info == 0)
12150             continue;
12151
12152           /* Walk over each section attached to the input bfd.  */
12153           for (section = input_bfd->sections;
12154                section != NULL;
12155                section = section->next)
12156             {
12157               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12158
12159               /* If there aren't any relocs, then there's nothing more
12160                  to do.  */
12161               if ((section->flags & SEC_RELOC) == 0
12162                   || (section->flags & SEC_ALLOC) == 0
12163                   || (section->flags & SEC_LOAD) == 0
12164                   || (section->flags & SEC_CODE) == 0
12165                   || section->reloc_count == 0)
12166                 continue;
12167
12168               /* If this section is a link-once section that will be
12169                  discarded, then don't create any stubs.  */
12170               if (section->output_section == NULL
12171                   || section->output_section->owner != info->output_bfd)
12172                 continue;
12173
12174               /* Get the relocs.  */
12175               internal_relocs
12176                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12177                                              info->keep_memory);
12178               if (internal_relocs == NULL)
12179                 goto error_ret_free_local;
12180
12181               /* Now examine each relocation.  */
12182               irela = internal_relocs;
12183               irelaend = irela + section->reloc_count;
12184               for (; irela < irelaend; irela++)
12185                 {
12186                   enum elf_ppc64_reloc_type r_type;
12187                   unsigned int r_indx;
12188                   enum ppc_stub_type stub_type;
12189                   struct ppc_stub_hash_entry *stub_entry;
12190                   asection *sym_sec, *code_sec;
12191                   bfd_vma sym_value, code_value;
12192                   bfd_vma destination;
12193                   unsigned long local_off;
12194                   bfd_boolean ok_dest;
12195                   struct ppc_link_hash_entry *hash;
12196                   struct ppc_link_hash_entry *fdh;
12197                   struct elf_link_hash_entry *h;
12198                   Elf_Internal_Sym *sym;
12199                   char *stub_name;
12200                   const asection *id_sec;
12201                   struct _opd_sec_data *opd;
12202                   struct plt_entry *plt_ent;
12203
12204                   r_type = ELF64_R_TYPE (irela->r_info);
12205                   r_indx = ELF64_R_SYM (irela->r_info);
12206
12207                   if (r_type >= R_PPC64_max)
12208                     {
12209                       bfd_set_error (bfd_error_bad_value);
12210                       goto error_ret_free_internal;
12211                     }
12212
12213                   /* Only look for stubs on branch instructions.  */
12214                   if (r_type != R_PPC64_REL24
12215                       && r_type != R_PPC64_REL14
12216                       && r_type != R_PPC64_REL14_BRTAKEN
12217                       && r_type != R_PPC64_REL14_BRNTAKEN)
12218                     continue;
12219
12220                   /* Now determine the call target, its name, value,
12221                      section.  */
12222                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12223                                   r_indx, input_bfd))
12224                     goto error_ret_free_internal;
12225                   hash = (struct ppc_link_hash_entry *) h;
12226
12227                   ok_dest = FALSE;
12228                   fdh = NULL;
12229                   sym_value = 0;
12230                   if (hash == NULL)
12231                     {
12232                       sym_value = sym->st_value;
12233                       ok_dest = TRUE;
12234                     }
12235                   else if (hash->elf.root.type == bfd_link_hash_defined
12236                            || hash->elf.root.type == bfd_link_hash_defweak)
12237                     {
12238                       sym_value = hash->elf.root.u.def.value;
12239                       if (sym_sec->output_section != NULL)
12240                         ok_dest = TRUE;
12241                     }
12242                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12243                            || hash->elf.root.type == bfd_link_hash_undefined)
12244                     {
12245                       /* Recognise an old ABI func code entry sym, and
12246                          use the func descriptor sym instead if it is
12247                          defined.  */
12248                       if (hash->elf.root.root.string[0] == '.'
12249                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12250                         {
12251                           if (fdh->elf.root.type == bfd_link_hash_defined
12252                               || fdh->elf.root.type == bfd_link_hash_defweak)
12253                             {
12254                               sym_sec = fdh->elf.root.u.def.section;
12255                               sym_value = fdh->elf.root.u.def.value;
12256                               if (sym_sec->output_section != NULL)
12257                                 ok_dest = TRUE;
12258                             }
12259                           else
12260                             fdh = NULL;
12261                         }
12262                     }
12263                   else
12264                     {
12265                       bfd_set_error (bfd_error_bad_value);
12266                       goto error_ret_free_internal;
12267                     }
12268
12269                   destination = 0;
12270                   local_off = 0;
12271                   if (ok_dest)
12272                     {
12273                       sym_value += irela->r_addend;
12274                       destination = (sym_value
12275                                      + sym_sec->output_offset
12276                                      + sym_sec->output_section->vma);
12277                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12278                                                             ? hash->elf.other
12279                                                             : sym->st_other);
12280                     }
12281
12282                   code_sec = sym_sec;
12283                   code_value = sym_value;
12284                   opd = get_opd_info (sym_sec);
12285                   if (opd != NULL)
12286                     {
12287                       bfd_vma dest;
12288
12289                       if (hash == NULL && opd->adjust != NULL)
12290                         {
12291                           long adjust = opd->adjust[OPD_NDX (sym_value)];
12292                           if (adjust == -1)
12293                             continue;
12294                           code_value += adjust;
12295                           sym_value += adjust;
12296                         }
12297                       dest = opd_entry_value (sym_sec, sym_value,
12298                                               &code_sec, &code_value, FALSE);
12299                       if (dest != (bfd_vma) -1)
12300                         {
12301                           destination = dest;
12302                           if (fdh != NULL)
12303                             {
12304                               /* Fixup old ABI sym to point at code
12305                                  entry.  */
12306                               hash->elf.root.type = bfd_link_hash_defweak;
12307                               hash->elf.root.u.def.section = code_sec;
12308                               hash->elf.root.u.def.value = code_value;
12309                             }
12310                         }
12311                     }
12312
12313                   /* Determine what (if any) linker stub is needed.  */
12314                   plt_ent = NULL;
12315                   stub_type = ppc_type_of_stub (section, irela, &hash,
12316                                                 &plt_ent, destination,
12317                                                 local_off);
12318
12319                   if (stub_type != ppc_stub_plt_call)
12320                     {
12321                       /* Check whether we need a TOC adjusting stub.
12322                          Since the linker pastes together pieces from
12323                          different object files when creating the
12324                          _init and _fini functions, it may be that a
12325                          call to what looks like a local sym is in
12326                          fact a call needing a TOC adjustment.  */
12327                       if (code_sec != NULL
12328                           && code_sec->output_section != NULL
12329                           && (htab->sec_info[code_sec->id].toc_off
12330                               != htab->sec_info[section->id].toc_off)
12331                           && (code_sec->has_toc_reloc
12332                               || code_sec->makes_toc_func_call))
12333                         stub_type = ppc_stub_long_branch_r2off;
12334                     }
12335
12336                   if (stub_type == ppc_stub_none)
12337                     continue;
12338
12339                   /* __tls_get_addr calls might be eliminated.  */
12340                   if (stub_type != ppc_stub_plt_call
12341                       && hash != NULL
12342                       && (hash == htab->tls_get_addr
12343                           || hash == htab->tls_get_addr_fd)
12344                       && section->has_tls_reloc
12345                       && irela != internal_relocs)
12346                     {
12347                       /* Get tls info.  */
12348                       unsigned char *tls_mask;
12349
12350                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12351                                          irela - 1, input_bfd))
12352                         goto error_ret_free_internal;
12353                       if (*tls_mask != 0)
12354                         continue;
12355                     }
12356
12357                   if (stub_type == ppc_stub_plt_call
12358                       && irela + 1 < irelaend
12359                       && irela[1].r_offset == irela->r_offset + 4
12360                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12361                     {
12362                       if (!tocsave_find (htab, INSERT,
12363                                          &local_syms, irela + 1, input_bfd))
12364                         goto error_ret_free_internal;
12365                     }
12366                   else if (stub_type == ppc_stub_plt_call)
12367                     stub_type = ppc_stub_plt_call_r2save;
12368
12369                   /* Support for grouping stub sections.  */
12370                   id_sec = htab->sec_info[section->id].u.group->link_sec;
12371
12372                   /* Get the name of this stub.  */
12373                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12374                   if (!stub_name)
12375                     goto error_ret_free_internal;
12376
12377                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12378                                                      stub_name, FALSE, FALSE);
12379                   if (stub_entry != NULL)
12380                     {
12381                       /* The proper stub has already been created.  */
12382                       free (stub_name);
12383                       if (stub_type == ppc_stub_plt_call_r2save)
12384                         stub_entry->stub_type = stub_type;
12385                       continue;
12386                     }
12387
12388                   stub_entry = ppc_add_stub (stub_name, section, info);
12389                   if (stub_entry == NULL)
12390                     {
12391                       free (stub_name);
12392                     error_ret_free_internal:
12393                       if (elf_section_data (section)->relocs == NULL)
12394                         free (internal_relocs);
12395                     error_ret_free_local:
12396                       if (local_syms != NULL
12397                           && (symtab_hdr->contents
12398                               != (unsigned char *) local_syms))
12399                         free (local_syms);
12400                       return FALSE;
12401                     }
12402
12403                   stub_entry->stub_type = stub_type;
12404                   if (stub_type != ppc_stub_plt_call
12405                       && stub_type != ppc_stub_plt_call_r2save)
12406                     {
12407                       stub_entry->target_value = code_value;
12408                       stub_entry->target_section = code_sec;
12409                     }
12410                   else
12411                     {
12412                       stub_entry->target_value = sym_value;
12413                       stub_entry->target_section = sym_sec;
12414                     }
12415                   stub_entry->h = hash;
12416                   stub_entry->plt_ent = plt_ent;
12417                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12418
12419                   if (stub_entry->h != NULL)
12420                     htab->stub_globals += 1;
12421                 }
12422
12423               /* We're done with the internal relocs, free them.  */
12424               if (elf_section_data (section)->relocs != internal_relocs)
12425                 free (internal_relocs);
12426             }
12427
12428           if (local_syms != NULL
12429               && symtab_hdr->contents != (unsigned char *) local_syms)
12430             {
12431               if (!info->keep_memory)
12432                 free (local_syms);
12433               else
12434                 symtab_hdr->contents = (unsigned char *) local_syms;
12435             }
12436         }
12437
12438       /* We may have added some stubs.  Find out the new size of the
12439          stub sections.  */
12440       for (stub_sec = htab->params->stub_bfd->sections;
12441            stub_sec != NULL;
12442            stub_sec = stub_sec->next)
12443         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12444           {
12445             stub_sec->rawsize = stub_sec->size;
12446             stub_sec->size = 0;
12447             stub_sec->reloc_count = 0;
12448             stub_sec->flags &= ~SEC_RELOC;
12449           }
12450
12451       htab->brlt->size = 0;
12452       htab->brlt->reloc_count = 0;
12453       htab->brlt->flags &= ~SEC_RELOC;
12454       if (htab->relbrlt != NULL)
12455         htab->relbrlt->size = 0;
12456
12457       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12458
12459       for (group = htab->group; group != NULL; group = group->next)
12460         if (group->needs_save_res)
12461           group->stub_sec->size += htab->sfpr->size;
12462
12463       if (info->emitrelocations
12464           && htab->glink != NULL && htab->glink->size != 0)
12465         {
12466           htab->glink->reloc_count = 1;
12467           htab->glink->flags |= SEC_RELOC;
12468         }
12469
12470       if (htab->glink_eh_frame != NULL
12471           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12472           && htab->glink_eh_frame->output_section->size != 0)
12473         {
12474           size_t size = 0, align;
12475
12476           for (stub_sec = htab->params->stub_bfd->sections;
12477                stub_sec != NULL;
12478                stub_sec = stub_sec->next)
12479             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12480               size += 24;
12481           if (htab->glink != NULL && htab->glink->size != 0)
12482             size += 24;
12483           if (size != 0)
12484             size += sizeof (glink_eh_frame_cie);
12485           align = 1;
12486           align <<= htab->glink_eh_frame->output_section->alignment_power;
12487           align -= 1;
12488           size = (size + align) & ~align;
12489           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12490           htab->glink_eh_frame->size = size;
12491         }
12492
12493       if (htab->params->plt_stub_align != 0)
12494         for (stub_sec = htab->params->stub_bfd->sections;
12495              stub_sec != NULL;
12496              stub_sec = stub_sec->next)
12497           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12498             stub_sec->size = ((stub_sec->size
12499                                + (1 << htab->params->plt_stub_align) - 1)
12500                               & (-1 << htab->params->plt_stub_align));
12501
12502       for (stub_sec = htab->params->stub_bfd->sections;
12503            stub_sec != NULL;
12504            stub_sec = stub_sec->next)
12505         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12506             && stub_sec->rawsize != stub_sec->size)
12507           break;
12508
12509       /* Exit from this loop when no stubs have been added, and no stubs
12510          have changed size.  */
12511       if (stub_sec == NULL
12512           && (htab->glink_eh_frame == NULL
12513               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12514         break;
12515
12516       /* Ask the linker to do its stuff.  */
12517       (*htab->params->layout_sections_again) ();
12518     }
12519
12520   if (htab->glink_eh_frame != NULL
12521       && htab->glink_eh_frame->size != 0)
12522     {
12523       bfd_vma val;
12524       bfd_byte *p, *last_fde;
12525       size_t last_fde_len, size, align, pad;
12526       asection *stub_sec;
12527
12528       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12529       if (p == NULL)
12530         return FALSE;
12531       htab->glink_eh_frame->contents = p;
12532       last_fde = p;
12533
12534       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12535       /* CIE length (rewrite in case little-endian).  */
12536       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12537       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12538       p += sizeof (glink_eh_frame_cie);
12539
12540       for (stub_sec = htab->params->stub_bfd->sections;
12541            stub_sec != NULL;
12542            stub_sec = stub_sec->next)
12543         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12544           {
12545             last_fde = p;
12546             last_fde_len = 20;
12547             /* FDE length.  */
12548             bfd_put_32 (htab->elf.dynobj, 20, p);
12549             p += 4;
12550             /* CIE pointer.  */
12551             val = p - htab->glink_eh_frame->contents;
12552             bfd_put_32 (htab->elf.dynobj, val, p);
12553             p += 4;
12554             /* Offset to stub section, written later.  */
12555             p += 4;
12556             /* stub section size.  */
12557             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12558             p += 4;
12559             /* Augmentation.  */
12560             p += 1;
12561             /* Pad.  */
12562             p += 7;
12563           }
12564       if (htab->glink != NULL && htab->glink->size != 0)
12565         {
12566           last_fde = p;
12567           last_fde_len = 20;
12568           /* FDE length.  */
12569           bfd_put_32 (htab->elf.dynobj, 20, p);
12570           p += 4;
12571           /* CIE pointer.  */
12572           val = p - htab->glink_eh_frame->contents;
12573           bfd_put_32 (htab->elf.dynobj, val, p);
12574           p += 4;
12575           /* Offset to .glink, written later.  */
12576           p += 4;
12577           /* .glink size.  */
12578           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12579           p += 4;
12580           /* Augmentation.  */
12581           p += 1;
12582
12583           *p++ = DW_CFA_advance_loc + 1;
12584           *p++ = DW_CFA_register;
12585           *p++ = 65;
12586           *p++ = htab->opd_abi ? 12 : 0;
12587           *p++ = DW_CFA_advance_loc + 4;
12588           *p++ = DW_CFA_restore_extended;
12589           *p++ = 65;
12590         }
12591       /* Subsume any padding into the last FDE if user .eh_frame
12592          sections are aligned more than glink_eh_frame.  Otherwise any
12593          zero padding will be seen as a terminator.  */
12594       size = p - htab->glink_eh_frame->contents;
12595       align = 1;
12596       align <<= htab->glink_eh_frame->output_section->alignment_power;
12597       align -= 1;
12598       pad = ((size + align) & ~align) - size;
12599       htab->glink_eh_frame->size = size + pad;
12600       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12601     }
12602
12603   maybe_strip_output (info, htab->brlt);
12604   if (htab->glink_eh_frame != NULL)
12605     maybe_strip_output (info, htab->glink_eh_frame);
12606
12607   return TRUE;
12608 }
12609
12610 /* Called after we have determined section placement.  If sections
12611    move, we'll be called again.  Provide a value for TOCstart.  */
12612
12613 bfd_vma
12614 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12615 {
12616   asection *s;
12617   bfd_vma TOCstart, adjust;
12618
12619   if (info != NULL)
12620     {
12621       struct elf_link_hash_entry *h;
12622       struct elf_link_hash_table *htab = elf_hash_table (info);
12623
12624       if (is_elf_hash_table (htab)
12625           && htab->hgot != NULL)
12626         h = htab->hgot;
12627       else
12628         {
12629           h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12630           if (is_elf_hash_table (htab))
12631             htab->hgot = h;
12632         }
12633       if (h != NULL
12634           && h->root.type == bfd_link_hash_defined
12635           && !h->root.linker_def
12636           && (!is_elf_hash_table (htab)
12637               || h->def_regular))
12638         {
12639           TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12640                       + h->root.u.def.section->output_offset
12641                       + h->root.u.def.section->output_section->vma);
12642           _bfd_set_gp_value (obfd, TOCstart);
12643           return TOCstart;
12644         }
12645     }
12646
12647   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12648      order.  The TOC starts where the first of these sections starts.  */
12649   s = bfd_get_section_by_name (obfd, ".got");
12650   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12651     s = bfd_get_section_by_name (obfd, ".toc");
12652   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12653     s = bfd_get_section_by_name (obfd, ".tocbss");
12654   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12655     s = bfd_get_section_by_name (obfd, ".plt");
12656   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12657     {
12658       /* This may happen for
12659          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12660          .toc directive
12661          o  bad linker script
12662          o --gc-sections and empty TOC sections
12663
12664          FIXME: Warn user?  */
12665
12666       /* Look for a likely section.  We probably won't even be
12667          using TOCstart.  */
12668       for (s = obfd->sections; s != NULL; s = s->next)
12669         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12670                          | SEC_EXCLUDE))
12671             == (SEC_ALLOC | SEC_SMALL_DATA))
12672           break;
12673       if (s == NULL)
12674         for (s = obfd->sections; s != NULL; s = s->next)
12675           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12676               == (SEC_ALLOC | SEC_SMALL_DATA))
12677             break;
12678       if (s == NULL)
12679         for (s = obfd->sections; s != NULL; s = s->next)
12680           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12681               == SEC_ALLOC)
12682             break;
12683       if (s == NULL)
12684         for (s = obfd->sections; s != NULL; s = s->next)
12685           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12686             break;
12687     }
12688
12689   TOCstart = 0;
12690   if (s != NULL)
12691     TOCstart = s->output_section->vma + s->output_offset;
12692
12693   /* Force alignment.  */
12694   adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12695   TOCstart -= adjust;
12696   _bfd_set_gp_value (obfd, TOCstart);
12697
12698   if (info != NULL && s != NULL)
12699     {
12700       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12701
12702       if (htab != NULL)
12703         {
12704           if (htab->elf.hgot != NULL)
12705             {
12706               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12707               htab->elf.hgot->root.u.def.section = s;
12708             }
12709         }
12710       else
12711         {
12712           struct bfd_link_hash_entry *bh = NULL;
12713           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12714                                             s, TOC_BASE_OFF - adjust,
12715                                             NULL, FALSE, FALSE, &bh);
12716         }
12717     }
12718   return TOCstart;
12719 }
12720
12721 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12722    write out any global entry stubs.  */
12723
12724 static bfd_boolean
12725 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12726 {
12727   struct bfd_link_info *info;
12728   struct ppc_link_hash_table *htab;
12729   struct plt_entry *pent;
12730   asection *s;
12731
12732   if (h->root.type == bfd_link_hash_indirect)
12733     return TRUE;
12734
12735   if (!h->pointer_equality_needed)
12736     return TRUE;
12737
12738   if (h->def_regular)
12739     return TRUE;
12740
12741   info = inf;
12742   htab = ppc_hash_table (info);
12743   if (htab == NULL)
12744     return FALSE;
12745
12746   s = htab->glink;
12747   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12748     if (pent->plt.offset != (bfd_vma) -1
12749         && pent->addend == 0)
12750       {
12751         bfd_byte *p;
12752         asection *plt;
12753         bfd_vma off;
12754
12755         p = s->contents + h->root.u.def.value;
12756         plt = htab->elf.splt;
12757         if (!htab->elf.dynamic_sections_created
12758             || h->dynindx == -1)
12759           plt = htab->elf.iplt;
12760         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12761         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12762
12763         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12764           {
12765             info->callbacks->einfo
12766               (_("%P: linkage table error against `%T'\n"),
12767                h->root.root.string);
12768             bfd_set_error (bfd_error_bad_value);
12769             htab->stub_error = TRUE;
12770           }
12771
12772         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12773         if (htab->params->emit_stub_syms)
12774           {
12775             size_t len = strlen (h->root.root.string);
12776             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12777
12778             if (name == NULL)
12779               return FALSE;
12780
12781             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12782             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12783             if (h == NULL)
12784               return FALSE;
12785             if (h->root.type == bfd_link_hash_new)
12786               {
12787                 h->root.type = bfd_link_hash_defined;
12788                 h->root.u.def.section = s;
12789                 h->root.u.def.value = p - s->contents;
12790                 h->ref_regular = 1;
12791                 h->def_regular = 1;
12792                 h->ref_regular_nonweak = 1;
12793                 h->forced_local = 1;
12794                 h->non_elf = 0;
12795                 h->root.linker_def = 1;
12796               }
12797           }
12798
12799         if (PPC_HA (off) != 0)
12800           {
12801             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12802             p += 4;
12803           }
12804         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12805         p += 4;
12806         bfd_put_32 (s->owner, MTCTR_R12, p);
12807         p += 4;
12808         bfd_put_32 (s->owner, BCTR, p);
12809         break;
12810       }
12811   return TRUE;
12812 }
12813
12814 /* Build all the stubs associated with the current output file.
12815    The stubs are kept in a hash table attached to the main linker
12816    hash table.  This function is called via gldelf64ppc_finish.  */
12817
12818 bfd_boolean
12819 ppc64_elf_build_stubs (struct bfd_link_info *info,
12820                        char **stats)
12821 {
12822   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12823   struct map_stub *group;
12824   asection *stub_sec;
12825   bfd_byte *p;
12826   int stub_sec_count = 0;
12827
12828   if (htab == NULL)
12829     return FALSE;
12830
12831   /* Allocate memory to hold the linker stubs.  */
12832   for (stub_sec = htab->params->stub_bfd->sections;
12833        stub_sec != NULL;
12834        stub_sec = stub_sec->next)
12835     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12836         && stub_sec->size != 0)
12837       {
12838         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12839         if (stub_sec->contents == NULL)
12840           return FALSE;
12841         /* We want to check that built size is the same as calculated
12842            size.  rawsize is a convenient location to use.  */
12843         stub_sec->rawsize = stub_sec->size;
12844         stub_sec->size = 0;
12845       }
12846
12847   if (htab->glink != NULL && htab->glink->size != 0)
12848     {
12849       unsigned int indx;
12850       bfd_vma plt0;
12851
12852       /* Build the .glink plt call stub.  */
12853       if (htab->params->emit_stub_syms)
12854         {
12855           struct elf_link_hash_entry *h;
12856           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12857                                     TRUE, FALSE, FALSE);
12858           if (h == NULL)
12859             return FALSE;
12860           if (h->root.type == bfd_link_hash_new)
12861             {
12862               h->root.type = bfd_link_hash_defined;
12863               h->root.u.def.section = htab->glink;
12864               h->root.u.def.value = 8;
12865               h->ref_regular = 1;
12866               h->def_regular = 1;
12867               h->ref_regular_nonweak = 1;
12868               h->forced_local = 1;
12869               h->non_elf = 0;
12870               h->root.linker_def = 1;
12871             }
12872         }
12873       plt0 = (htab->elf.splt->output_section->vma
12874               + htab->elf.splt->output_offset
12875               - 16);
12876       if (info->emitrelocations)
12877         {
12878           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12879           if (r == NULL)
12880             return FALSE;
12881           r->r_offset = (htab->glink->output_offset
12882                          + htab->glink->output_section->vma);
12883           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12884           r->r_addend = plt0;
12885         }
12886       p = htab->glink->contents;
12887       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12888       bfd_put_64 (htab->glink->owner, plt0, p);
12889       p += 8;
12890       if (htab->opd_abi)
12891         {
12892           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12893           p += 4;
12894           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12895           p += 4;
12896           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12897           p += 4;
12898           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12899           p += 4;
12900           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12901           p += 4;
12902           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12903           p += 4;
12904           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12905           p += 4;
12906           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12907           p += 4;
12908           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12909           p += 4;
12910           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12911           p += 4;
12912         }
12913       else
12914         {
12915           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12916           p += 4;
12917           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12918           p += 4;
12919           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12920           p += 4;
12921           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12922           p += 4;
12923           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12924           p += 4;
12925           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12926           p += 4;
12927           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12928           p += 4;
12929           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12930           p += 4;
12931           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12932           p += 4;
12933           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12934           p += 4;
12935           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12936           p += 4;
12937           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12938           p += 4;
12939         }
12940       bfd_put_32 (htab->glink->owner, BCTR, p);
12941       p += 4;
12942       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12943         {
12944           bfd_put_32 (htab->glink->owner, NOP, p);
12945           p += 4;
12946         }
12947
12948       /* Build the .glink lazy link call stubs.  */
12949       indx = 0;
12950       while (p < htab->glink->contents + htab->glink->rawsize)
12951         {
12952           if (htab->opd_abi)
12953             {
12954               if (indx < 0x8000)
12955                 {
12956                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12957                   p += 4;
12958                 }
12959               else
12960                 {
12961                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12962                   p += 4;
12963                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12964                               p);
12965                   p += 4;
12966                 }
12967             }
12968           bfd_put_32 (htab->glink->owner,
12969                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12970           indx++;
12971           p += 4;
12972         }
12973
12974       /* Build .glink global entry stubs.  */
12975       if (htab->glink->size > htab->glink->rawsize)
12976         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12977     }
12978
12979   if (htab->brlt != NULL && htab->brlt->size != 0)
12980     {
12981       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12982                                          htab->brlt->size);
12983       if (htab->brlt->contents == NULL)
12984         return FALSE;
12985     }
12986   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12987     {
12988       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12989                                             htab->relbrlt->size);
12990       if (htab->relbrlt->contents == NULL)
12991         return FALSE;
12992     }
12993
12994   /* Build the stubs as directed by the stub hash table.  */
12995   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12996
12997   for (group = htab->group; group != NULL; group = group->next)
12998     if (group->needs_save_res)
12999       {
13000         stub_sec = group->stub_sec;
13001         memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13002                 htab->sfpr->size);
13003         if (htab->params->emit_stub_syms)
13004           {
13005             unsigned int i;
13006
13007             for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13008               if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13009                 return FALSE;
13010           }
13011         stub_sec->size += htab->sfpr->size;
13012       }
13013
13014   if (htab->relbrlt != NULL)
13015     htab->relbrlt->reloc_count = 0;
13016
13017   if (htab->params->plt_stub_align != 0)
13018     for (stub_sec = htab->params->stub_bfd->sections;
13019          stub_sec != NULL;
13020          stub_sec = stub_sec->next)
13021       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13022         stub_sec->size = ((stub_sec->size
13023                            + (1 << htab->params->plt_stub_align) - 1)
13024                           & (-1 << htab->params->plt_stub_align));
13025
13026   for (stub_sec = htab->params->stub_bfd->sections;
13027        stub_sec != NULL;
13028        stub_sec = stub_sec->next)
13029     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13030       {
13031         stub_sec_count += 1;
13032         if (stub_sec->rawsize != stub_sec->size)
13033           break;
13034       }
13035
13036   /* Note that the glink_eh_frame check here is not only testing that
13037      the generated size matched the calculated size but also that
13038      bfd_elf_discard_info didn't make any changes to the section.  */
13039   if (stub_sec != NULL
13040       || (htab->glink_eh_frame != NULL
13041           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13042     {
13043       htab->stub_error = TRUE;
13044       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13045     }
13046
13047   if (htab->stub_error)
13048     return FALSE;
13049
13050   if (stats != NULL)
13051     {
13052       *stats = bfd_malloc (500);
13053       if (*stats == NULL)
13054         return FALSE;
13055
13056       sprintf (*stats, _("linker stubs in %u group%s\n"
13057                          "  branch       %lu\n"
13058                          "  toc adjust   %lu\n"
13059                          "  long branch  %lu\n"
13060                          "  long toc adj %lu\n"
13061                          "  plt call     %lu\n"
13062                          "  plt call toc %lu\n"
13063                          "  global entry %lu"),
13064                stub_sec_count,
13065                stub_sec_count == 1 ? "" : "s",
13066                htab->stub_count[ppc_stub_long_branch - 1],
13067                htab->stub_count[ppc_stub_long_branch_r2off - 1],
13068                htab->stub_count[ppc_stub_plt_branch - 1],
13069                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13070                htab->stub_count[ppc_stub_plt_call - 1],
13071                htab->stub_count[ppc_stub_plt_call_r2save - 1],
13072                htab->stub_count[ppc_stub_global_entry - 1]);
13073     }
13074   return TRUE;
13075 }
13076
13077 /* This function undoes the changes made by add_symbol_adjust.  */
13078
13079 static bfd_boolean
13080 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13081 {
13082   struct ppc_link_hash_entry *eh;
13083
13084   if (h->root.type == bfd_link_hash_indirect)
13085     return TRUE;
13086
13087   eh = (struct ppc_link_hash_entry *) h;
13088   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13089     return TRUE;
13090
13091   eh->elf.root.type = bfd_link_hash_undefined;
13092   return TRUE;
13093 }
13094
13095 void
13096 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13097 {
13098   struct ppc_link_hash_table *htab = ppc_hash_table (info);
13099
13100   if (htab != NULL)
13101     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13102 }
13103
13104 /* What to do when ld finds relocations against symbols defined in
13105    discarded sections.  */
13106
13107 static unsigned int
13108 ppc64_elf_action_discarded (asection *sec)
13109 {
13110   if (strcmp (".opd", sec->name) == 0)
13111     return 0;
13112
13113   if (strcmp (".toc", sec->name) == 0)
13114     return 0;
13115
13116   if (strcmp (".toc1", sec->name) == 0)
13117     return 0;
13118
13119   return _bfd_elf_default_action_discarded (sec);
13120 }
13121
13122 /* The RELOCATE_SECTION function is called by the ELF backend linker
13123    to handle the relocations for a section.
13124
13125    The relocs are always passed as Rela structures; if the section
13126    actually uses Rel structures, the r_addend field will always be
13127    zero.
13128
13129    This function is responsible for adjust the section contents as
13130    necessary, and (if using Rela relocs and generating a
13131    relocatable output file) adjusting the reloc addend as
13132    necessary.
13133
13134    This function does not have to worry about setting the reloc
13135    address or the reloc symbol index.
13136
13137    LOCAL_SYMS is a pointer to the swapped in local symbols.
13138
13139    LOCAL_SECTIONS is an array giving the section in the input file
13140    corresponding to the st_shndx field of each local symbol.
13141
13142    The global hash table entry for the global symbols can be found
13143    via elf_sym_hashes (input_bfd).
13144
13145    When generating relocatable output, this function must handle
13146    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
13147    going to be the section symbol corresponding to the output
13148    section, which means that the addend must be adjusted
13149    accordingly.  */
13150
13151 static bfd_boolean
13152 ppc64_elf_relocate_section (bfd *output_bfd,
13153                             struct bfd_link_info *info,
13154                             bfd *input_bfd,
13155                             asection *input_section,
13156                             bfd_byte *contents,
13157                             Elf_Internal_Rela *relocs,
13158                             Elf_Internal_Sym *local_syms,
13159                             asection **local_sections)
13160 {
13161   struct ppc_link_hash_table *htab;
13162   Elf_Internal_Shdr *symtab_hdr;
13163   struct elf_link_hash_entry **sym_hashes;
13164   Elf_Internal_Rela *rel;
13165   Elf_Internal_Rela *relend;
13166   Elf_Internal_Rela outrel;
13167   bfd_byte *loc;
13168   struct got_entry **local_got_ents;
13169   bfd_vma TOCstart;
13170   bfd_boolean ret = TRUE;
13171   bfd_boolean is_opd;
13172   /* Assume 'at' branch hints.  */
13173   bfd_boolean is_isa_v2 = TRUE;
13174   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13175
13176   /* Initialize howto table if needed.  */
13177   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13178     ppc_howto_init ();
13179
13180   htab = ppc_hash_table (info);
13181   if (htab == NULL)
13182     return FALSE;
13183
13184   /* Don't relocate stub sections.  */
13185   if (input_section->owner == htab->params->stub_bfd)
13186     return TRUE;
13187
13188   BFD_ASSERT (is_ppc64_elf (input_bfd));
13189
13190   local_got_ents = elf_local_got_ents (input_bfd);
13191   TOCstart = elf_gp (output_bfd);
13192   symtab_hdr = &elf_symtab_hdr (input_bfd);
13193   sym_hashes = elf_sym_hashes (input_bfd);
13194   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13195
13196   rel = relocs;
13197   relend = relocs + input_section->reloc_count;
13198   for (; rel < relend; rel++)
13199     {
13200       enum elf_ppc64_reloc_type r_type;
13201       bfd_vma addend;
13202       bfd_reloc_status_type r;
13203       Elf_Internal_Sym *sym;
13204       asection *sec;
13205       struct elf_link_hash_entry *h_elf;
13206       struct ppc_link_hash_entry *h;
13207       struct ppc_link_hash_entry *fdh;
13208       const char *sym_name;
13209       unsigned long r_symndx, toc_symndx;
13210       bfd_vma toc_addend;
13211       unsigned char tls_mask, tls_gd, tls_type;
13212       unsigned char sym_type;
13213       bfd_vma relocation;
13214       bfd_boolean unresolved_reloc;
13215       bfd_boolean warned;
13216       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13217       unsigned int insn;
13218       unsigned int mask;
13219       struct ppc_stub_hash_entry *stub_entry;
13220       bfd_vma max_br_offset;
13221       bfd_vma from;
13222       const Elf_Internal_Rela orig_rel = *rel;
13223       reloc_howto_type *howto;
13224       struct reloc_howto_struct alt_howto;
13225
13226       r_type = ELF64_R_TYPE (rel->r_info);
13227       r_symndx = ELF64_R_SYM (rel->r_info);
13228
13229       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13230          symbol of the previous ADDR64 reloc.  The symbol gives us the
13231          proper TOC base to use.  */
13232       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13233           && rel != relocs
13234           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13235           && is_opd)
13236         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13237
13238       sym = NULL;
13239       sec = NULL;
13240       h_elf = NULL;
13241       sym_name = NULL;
13242       unresolved_reloc = FALSE;
13243       warned = FALSE;
13244
13245       if (r_symndx < symtab_hdr->sh_info)
13246         {
13247           /* It's a local symbol.  */
13248           struct _opd_sec_data *opd;
13249
13250           sym = local_syms + r_symndx;
13251           sec = local_sections[r_symndx];
13252           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13253           sym_type = ELF64_ST_TYPE (sym->st_info);
13254           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13255           opd = get_opd_info (sec);
13256           if (opd != NULL && opd->adjust != NULL)
13257             {
13258               long adjust = opd->adjust[OPD_NDX (sym->st_value
13259                                                  + rel->r_addend)];
13260               if (adjust == -1)
13261                 relocation = 0;
13262               else
13263                 {
13264                   /* If this is a relocation against the opd section sym
13265                      and we have edited .opd, adjust the reloc addend so
13266                      that ld -r and ld --emit-relocs output is correct.
13267                      If it is a reloc against some other .opd symbol,
13268                      then the symbol value will be adjusted later.  */
13269                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13270                     rel->r_addend += adjust;
13271                   else
13272                     relocation += adjust;
13273                 }
13274             }
13275         }
13276       else
13277         {
13278           bfd_boolean ignored;
13279
13280           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13281                                    r_symndx, symtab_hdr, sym_hashes,
13282                                    h_elf, sec, relocation,
13283                                    unresolved_reloc, warned, ignored);
13284           sym_name = h_elf->root.root.string;
13285           sym_type = h_elf->type;
13286           if (sec != NULL
13287               && sec->owner == output_bfd
13288               && strcmp (sec->name, ".opd") == 0)
13289             {
13290               /* This is a symbol defined in a linker script.  All
13291                  such are defined in output sections, even those
13292                  defined by simple assignment from a symbol defined in
13293                  an input section.  Transfer the symbol to an
13294                  appropriate input .opd section, so that a branch to
13295                  this symbol will be mapped to the location specified
13296                  by the opd entry.  */
13297               struct bfd_link_order *lo;
13298               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13299                 if (lo->type == bfd_indirect_link_order)
13300                   {
13301                     asection *isec = lo->u.indirect.section;
13302                     if (h_elf->root.u.def.value >= isec->output_offset
13303                         && h_elf->root.u.def.value < (isec->output_offset
13304                                                       + isec->size))
13305                       {
13306                         h_elf->root.u.def.value -= isec->output_offset;
13307                         h_elf->root.u.def.section = isec;
13308                         sec = isec;
13309                         break;
13310                       }
13311                   }
13312             }
13313         }
13314       h = (struct ppc_link_hash_entry *) h_elf;
13315
13316       if (sec != NULL && discarded_section (sec))
13317         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13318                                          rel, 1, relend,
13319                                          ppc64_elf_howto_table[r_type], 0,
13320                                          contents);
13321
13322       if (bfd_link_relocatable (info))
13323         continue;
13324
13325       if (h != NULL && &h->elf == htab->elf.hgot)
13326         {
13327           relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13328           sec = bfd_abs_section_ptr;
13329           unresolved_reloc = FALSE;
13330         }
13331
13332       /* TLS optimizations.  Replace instruction sequences and relocs
13333          based on information we collected in tls_optimize.  We edit
13334          RELOCS so that --emit-relocs will output something sensible
13335          for the final instruction stream.  */
13336       tls_mask = 0;
13337       tls_gd = 0;
13338       toc_symndx = 0;
13339       if (h != NULL)
13340         tls_mask = h->tls_mask;
13341       else if (local_got_ents != NULL)
13342         {
13343           struct plt_entry **local_plt = (struct plt_entry **)
13344             (local_got_ents + symtab_hdr->sh_info);
13345           unsigned char *lgot_masks = (unsigned char *)
13346             (local_plt + symtab_hdr->sh_info);
13347           tls_mask = lgot_masks[r_symndx];
13348         }
13349       if (tls_mask == 0
13350           && (r_type == R_PPC64_TLS
13351               || r_type == R_PPC64_TLSGD
13352               || r_type == R_PPC64_TLSLD))
13353         {
13354           /* Check for toc tls entries.  */
13355           unsigned char *toc_tls;
13356
13357           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13358                              &local_syms, rel, input_bfd))
13359             return FALSE;
13360
13361           if (toc_tls)
13362             tls_mask = *toc_tls;
13363         }
13364
13365       /* Check that tls relocs are used with tls syms, and non-tls
13366          relocs are used with non-tls syms.  */
13367       if (r_symndx != STN_UNDEF
13368           && r_type != R_PPC64_NONE
13369           && (h == NULL
13370               || h->elf.root.type == bfd_link_hash_defined
13371               || h->elf.root.type == bfd_link_hash_defweak)
13372           && (IS_PPC64_TLS_RELOC (r_type)
13373               != (sym_type == STT_TLS
13374                   || (sym_type == STT_SECTION
13375                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13376         {
13377           if (tls_mask != 0
13378               && (r_type == R_PPC64_TLS
13379                   || r_type == R_PPC64_TLSGD
13380                   || r_type == R_PPC64_TLSLD))
13381             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13382             ;
13383           else
13384             info->callbacks->einfo
13385               (!IS_PPC64_TLS_RELOC (r_type)
13386                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13387                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13388                input_bfd, input_section, rel->r_offset,
13389                ppc64_elf_howto_table[r_type]->name,
13390                sym_name);
13391         }
13392
13393       /* Ensure reloc mapping code below stays sane.  */
13394       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13395           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13396           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13397           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13398           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13399           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13400           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13401           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13402           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13403           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13404         abort ();
13405
13406       switch (r_type)
13407         {
13408         default:
13409           break;
13410
13411         case R_PPC64_LO_DS_OPT:
13412           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13413           if ((insn & (0x3f << 26)) != 58u << 26)
13414             abort ();
13415           insn += (14u << 26) - (58u << 26);
13416           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13417           r_type = R_PPC64_TOC16_LO;
13418           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13419           break;
13420
13421         case R_PPC64_TOC16:
13422         case R_PPC64_TOC16_LO:
13423         case R_PPC64_TOC16_DS:
13424         case R_PPC64_TOC16_LO_DS:
13425           {
13426             /* Check for toc tls entries.  */
13427             unsigned char *toc_tls;
13428             int retval;
13429
13430             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13431                                    &local_syms, rel, input_bfd);
13432             if (retval == 0)
13433               return FALSE;
13434
13435             if (toc_tls)
13436               {
13437                 tls_mask = *toc_tls;
13438                 if (r_type == R_PPC64_TOC16_DS
13439                     || r_type == R_PPC64_TOC16_LO_DS)
13440                   {
13441                     if (tls_mask != 0
13442                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13443                       goto toctprel;
13444                   }
13445                 else
13446                   {
13447                     /* If we found a GD reloc pair, then we might be
13448                        doing a GD->IE transition.  */
13449                     if (retval == 2)
13450                       {
13451                         tls_gd = TLS_TPRELGD;
13452                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13453                           goto tls_ldgd_opt;
13454                       }
13455                     else if (retval == 3)
13456                       {
13457                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13458                           goto tls_ldgd_opt;
13459                       }
13460                   }
13461               }
13462           }
13463           break;
13464
13465         case R_PPC64_GOT_TPREL16_HI:
13466         case R_PPC64_GOT_TPREL16_HA:
13467           if (tls_mask != 0
13468               && (tls_mask & TLS_TPREL) == 0)
13469             {
13470               rel->r_offset -= d_offset;
13471               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13472               r_type = R_PPC64_NONE;
13473               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13474             }
13475           break;
13476
13477         case R_PPC64_GOT_TPREL16_DS:
13478         case R_PPC64_GOT_TPREL16_LO_DS:
13479           if (tls_mask != 0
13480               && (tls_mask & TLS_TPREL) == 0)
13481             {
13482             toctprel:
13483               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13484               insn &= 31 << 21;
13485               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13486               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13487               r_type = R_PPC64_TPREL16_HA;
13488               if (toc_symndx != 0)
13489                 {
13490                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13491                   rel->r_addend = toc_addend;
13492                   /* We changed the symbol.  Start over in order to
13493                      get h, sym, sec etc. right.  */
13494                   rel--;
13495                   continue;
13496                 }
13497               else
13498                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13499             }
13500           break;
13501
13502         case R_PPC64_TLS:
13503           if (tls_mask != 0
13504               && (tls_mask & TLS_TPREL) == 0)
13505             {
13506               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13507               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13508               if (insn == 0)
13509                 abort ();
13510               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13511               /* Was PPC64_TLS which sits on insn boundary, now
13512                  PPC64_TPREL16_LO which is at low-order half-word.  */
13513               rel->r_offset += d_offset;
13514               r_type = R_PPC64_TPREL16_LO;
13515               if (toc_symndx != 0)
13516                 {
13517                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13518                   rel->r_addend = toc_addend;
13519                   /* We changed the symbol.  Start over in order to
13520                      get h, sym, sec etc. right.  */
13521                   rel--;
13522                   continue;
13523                 }
13524               else
13525                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13526             }
13527           break;
13528
13529         case R_PPC64_GOT_TLSGD16_HI:
13530         case R_PPC64_GOT_TLSGD16_HA:
13531           tls_gd = TLS_TPRELGD;
13532           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13533             goto tls_gdld_hi;
13534           break;
13535
13536         case R_PPC64_GOT_TLSLD16_HI:
13537         case R_PPC64_GOT_TLSLD16_HA:
13538           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13539             {
13540             tls_gdld_hi:
13541               if ((tls_mask & tls_gd) != 0)
13542                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13543                           + R_PPC64_GOT_TPREL16_DS);
13544               else
13545                 {
13546                   rel->r_offset -= d_offset;
13547                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13548                   r_type = R_PPC64_NONE;
13549                 }
13550               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13551             }
13552           break;
13553
13554         case R_PPC64_GOT_TLSGD16:
13555         case R_PPC64_GOT_TLSGD16_LO:
13556           tls_gd = TLS_TPRELGD;
13557           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13558             goto tls_ldgd_opt;
13559           break;
13560
13561         case R_PPC64_GOT_TLSLD16:
13562         case R_PPC64_GOT_TLSLD16_LO:
13563           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13564             {
13565               unsigned int insn1, insn2, insn3;
13566               bfd_vma offset;
13567
13568             tls_ldgd_opt:
13569               offset = (bfd_vma) -1;
13570               /* If not using the newer R_PPC64_TLSGD/LD to mark
13571                  __tls_get_addr calls, we must trust that the call
13572                  stays with its arg setup insns, ie. that the next
13573                  reloc is the __tls_get_addr call associated with
13574                  the current reloc.  Edit both insns.  */
13575               if (input_section->has_tls_get_addr_call
13576                   && rel + 1 < relend
13577                   && branch_reloc_hash_match (input_bfd, rel + 1,
13578                                               htab->tls_get_addr,
13579                                               htab->tls_get_addr_fd))
13580                 offset = rel[1].r_offset;
13581               /* We read the low GOT_TLS (or TOC16) insn because we
13582                  need to keep the destination reg.  It may be
13583                  something other than the usual r3, and moved to r3
13584                  before the call by intervening code.  */
13585               insn1 = bfd_get_32 (output_bfd,
13586                                   contents + rel->r_offset - d_offset);
13587               if ((tls_mask & tls_gd) != 0)
13588                 {
13589                   /* IE */
13590                   insn1 &= (0x1f << 21) | (0x1f << 16);
13591                   insn1 |= 58 << 26;    /* ld */
13592                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13593                   if (offset != (bfd_vma) -1)
13594                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13595                   if ((tls_mask & TLS_EXPLICIT) == 0)
13596                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13597                               + R_PPC64_GOT_TPREL16_DS);
13598                   else
13599                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13600                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13601                 }
13602               else
13603                 {
13604                   /* LE */
13605                   insn1 &= 0x1f << 21;
13606                   insn1 |= 0x3c0d0000;  /* addis r,13,0 */
13607                   insn2 = 0x38630000;   /* addi 3,3,0 */
13608                   if (tls_gd == 0)
13609                     {
13610                       /* Was an LD reloc.  */
13611                       if (toc_symndx)
13612                         sec = local_sections[toc_symndx];
13613                       for (r_symndx = 0;
13614                            r_symndx < symtab_hdr->sh_info;
13615                            r_symndx++)
13616                         if (local_sections[r_symndx] == sec)
13617                           break;
13618                       if (r_symndx >= symtab_hdr->sh_info)
13619                         r_symndx = STN_UNDEF;
13620                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13621                       if (r_symndx != STN_UNDEF)
13622                         rel->r_addend -= (local_syms[r_symndx].st_value
13623                                           + sec->output_offset
13624                                           + sec->output_section->vma);
13625                     }
13626                   else if (toc_symndx != 0)
13627                     {
13628                       r_symndx = toc_symndx;
13629                       rel->r_addend = toc_addend;
13630                     }
13631                   r_type = R_PPC64_TPREL16_HA;
13632                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13633                   if (offset != (bfd_vma) -1)
13634                     {
13635                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13636                                                     R_PPC64_TPREL16_LO);
13637                       rel[1].r_offset = offset + d_offset;
13638                       rel[1].r_addend = rel->r_addend;
13639                     }
13640                 }
13641               bfd_put_32 (output_bfd, insn1,
13642                           contents + rel->r_offset - d_offset);
13643               if (offset != (bfd_vma) -1)
13644                 {
13645                   insn3 = bfd_get_32 (output_bfd,
13646                                       contents + offset + 4);
13647                   if (insn3 == NOP
13648                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13649                     {
13650                       rel[1].r_offset += 4;
13651                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13652                       insn2 = NOP;
13653                     }
13654                   bfd_put_32 (output_bfd, insn2, contents + offset);
13655                 }
13656               if ((tls_mask & tls_gd) == 0
13657                   && (tls_gd == 0 || toc_symndx != 0))
13658                 {
13659                   /* We changed the symbol.  Start over in order
13660                      to get h, sym, sec etc. right.  */
13661                   rel--;
13662                   continue;
13663                 }
13664             }
13665           break;
13666
13667         case R_PPC64_TLSGD:
13668           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13669             {
13670               unsigned int insn2, insn3;
13671               bfd_vma offset = rel->r_offset;
13672
13673               if ((tls_mask & TLS_TPRELGD) != 0)
13674                 {
13675                   /* IE */
13676                   r_type = R_PPC64_NONE;
13677                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13678                 }
13679               else
13680                 {
13681                   /* LE */
13682                   if (toc_symndx != 0)
13683                     {
13684                       r_symndx = toc_symndx;
13685                       rel->r_addend = toc_addend;
13686                     }
13687                   r_type = R_PPC64_TPREL16_LO;
13688                   rel->r_offset = offset + d_offset;
13689                   insn2 = 0x38630000;   /* addi 3,3,0 */
13690                 }
13691               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13692               /* Zap the reloc on the _tls_get_addr call too.  */
13693               BFD_ASSERT (offset == rel[1].r_offset);
13694               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13695               insn3 = bfd_get_32 (output_bfd,
13696                                   contents + offset + 4);
13697               if (insn3 == NOP
13698                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13699                 {
13700                   rel->r_offset += 4;
13701                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13702                   insn2 = NOP;
13703                 }
13704               bfd_put_32 (output_bfd, insn2, contents + offset);
13705               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13706                 {
13707                   rel--;
13708                   continue;
13709                 }
13710             }
13711           break;
13712
13713         case R_PPC64_TLSLD:
13714           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13715             {
13716               unsigned int insn2, insn3;
13717               bfd_vma offset = rel->r_offset;
13718
13719               if (toc_symndx)
13720                 sec = local_sections[toc_symndx];
13721               for (r_symndx = 0;
13722                    r_symndx < symtab_hdr->sh_info;
13723                    r_symndx++)
13724                 if (local_sections[r_symndx] == sec)
13725                   break;
13726               if (r_symndx >= symtab_hdr->sh_info)
13727                 r_symndx = STN_UNDEF;
13728               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13729               if (r_symndx != STN_UNDEF)
13730                 rel->r_addend -= (local_syms[r_symndx].st_value
13731                                   + sec->output_offset
13732                                   + sec->output_section->vma);
13733
13734               r_type = R_PPC64_TPREL16_LO;
13735               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13736               rel->r_offset = offset + d_offset;
13737               /* Zap the reloc on the _tls_get_addr call too.  */
13738               BFD_ASSERT (offset == rel[1].r_offset);
13739               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13740               insn2 = 0x38630000;       /* addi 3,3,0 */
13741               insn3 = bfd_get_32 (output_bfd,
13742                                   contents + offset + 4);
13743               if (insn3 == NOP
13744                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13745                 {
13746                   rel->r_offset += 4;
13747                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13748                   insn2 = NOP;
13749                 }
13750               bfd_put_32 (output_bfd, insn2, contents + offset);
13751               rel--;
13752               continue;
13753             }
13754           break;
13755
13756         case R_PPC64_DTPMOD64:
13757           if (rel + 1 < relend
13758               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13759               && rel[1].r_offset == rel->r_offset + 8)
13760             {
13761               if ((tls_mask & TLS_GD) == 0)
13762                 {
13763                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13764                   if ((tls_mask & TLS_TPRELGD) != 0)
13765                     r_type = R_PPC64_TPREL64;
13766                   else
13767                     {
13768                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13769                       r_type = R_PPC64_NONE;
13770                     }
13771                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13772                 }
13773             }
13774           else
13775             {
13776               if ((tls_mask & TLS_LD) == 0)
13777                 {
13778                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13779                   r_type = R_PPC64_NONE;
13780                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13781                 }
13782             }
13783           break;
13784
13785         case R_PPC64_TPREL64:
13786           if ((tls_mask & TLS_TPREL) == 0)
13787             {
13788               r_type = R_PPC64_NONE;
13789               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13790             }
13791           break;
13792
13793         case R_PPC64_REL16_HA:
13794           /* If we are generating a non-PIC executable, edit
13795              .  0:      addis 2,12,.TOC.-0b@ha
13796              .          addi 2,2,.TOC.-0b@l
13797              used by ELFv2 global entry points to set up r2, to
13798              .          lis 2,.TOC.@ha
13799              .          addi 2,2,.TOC.@l
13800              if .TOC. is in range.  */
13801           if (!bfd_link_pic (info)
13802               && !info->traditional_format
13803               && h != NULL && &h->elf == htab->elf.hgot
13804               && rel + 1 < relend
13805               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13806               && rel[1].r_offset == rel->r_offset + 4
13807               && rel[1].r_addend == rel->r_addend + 4
13808               && relocation + 0x80008000 <= 0xffffffff)
13809             {
13810               unsigned int insn1, insn2;
13811               bfd_vma offset = rel->r_offset - d_offset;
13812               insn1 = bfd_get_32 (output_bfd, contents + offset);
13813               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13814               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13815                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13816                 {
13817                   r_type = R_PPC64_ADDR16_HA;
13818                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13819                   rel->r_addend -= d_offset;
13820                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13821                   rel[1].r_addend -= d_offset + 4;
13822                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13823                 }
13824             }
13825           break;
13826         }
13827
13828       /* Handle other relocations that tweak non-addend part of insn.  */
13829       insn = 0;
13830       max_br_offset = 1 << 25;
13831       addend = rel->r_addend;
13832       reloc_dest = DEST_NORMAL;
13833       switch (r_type)
13834         {
13835         default:
13836           break;
13837
13838         case R_PPC64_TOCSAVE:
13839           if (relocation + addend == (rel->r_offset
13840                                       + input_section->output_offset
13841                                       + input_section->output_section->vma)
13842               && tocsave_find (htab, NO_INSERT,
13843                                &local_syms, rel, input_bfd))
13844             {
13845               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13846               if (insn == NOP
13847                   || insn == CROR_151515 || insn == CROR_313131)
13848                 bfd_put_32 (input_bfd,
13849                             STD_R2_0R1 + STK_TOC (htab),
13850                             contents + rel->r_offset);
13851             }
13852           break;
13853
13854           /* Branch taken prediction relocations.  */
13855         case R_PPC64_ADDR14_BRTAKEN:
13856         case R_PPC64_REL14_BRTAKEN:
13857           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13858           /* Fall thru.  */
13859
13860           /* Branch not taken prediction relocations.  */
13861         case R_PPC64_ADDR14_BRNTAKEN:
13862         case R_PPC64_REL14_BRNTAKEN:
13863           insn |= bfd_get_32 (output_bfd,
13864                               contents + rel->r_offset) & ~(0x01 << 21);
13865           /* Fall thru.  */
13866
13867         case R_PPC64_REL14:
13868           max_br_offset = 1 << 15;
13869           /* Fall thru.  */
13870
13871         case R_PPC64_REL24:
13872           /* Calls to functions with a different TOC, such as calls to
13873              shared objects, need to alter the TOC pointer.  This is
13874              done using a linkage stub.  A REL24 branching to these
13875              linkage stubs needs to be followed by a nop, as the nop
13876              will be replaced with an instruction to restore the TOC
13877              base pointer.  */
13878           fdh = h;
13879           if (h != NULL
13880               && h->oh != NULL
13881               && h->oh->is_func_descriptor)
13882             fdh = ppc_follow_link (h->oh);
13883           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13884                                            htab);
13885           if (stub_entry != NULL
13886               && (stub_entry->stub_type == ppc_stub_plt_call
13887                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13888                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13889                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13890             {
13891               bfd_boolean can_plt_call = FALSE;
13892
13893               /* All of these stubs will modify r2, so there must be a
13894                  branch and link followed by a nop.  The nop is
13895                  replaced by an insn to restore r2.  */
13896               if (rel->r_offset + 8 <= input_section->size)
13897                 {
13898                   unsigned long br;
13899
13900                   br = bfd_get_32 (input_bfd,
13901                                    contents + rel->r_offset);
13902                   if ((br & 1) != 0)
13903                     {
13904                       unsigned long nop;
13905
13906                       nop = bfd_get_32 (input_bfd,
13907                                         contents + rel->r_offset + 4);
13908                       if (nop == NOP
13909                           || nop == CROR_151515 || nop == CROR_313131)
13910                         {
13911                           if (h != NULL
13912                               && (h == htab->tls_get_addr_fd
13913                                   || h == htab->tls_get_addr)
13914                               && htab->params->tls_get_addr_opt)
13915                             {
13916                               /* Special stub used, leave nop alone.  */
13917                             }
13918                           else
13919                             bfd_put_32 (input_bfd,
13920                                         LD_R2_0R1 + STK_TOC (htab),
13921                                         contents + rel->r_offset + 4);
13922                           can_plt_call = TRUE;
13923                         }
13924                     }
13925                 }
13926
13927               if (!can_plt_call && h != NULL)
13928                 {
13929                   const char *name = h->elf.root.root.string;
13930
13931                   if (*name == '.')
13932                     ++name;
13933
13934                   if (strncmp (name, "__libc_start_main", 17) == 0
13935                       && (name[17] == 0 || name[17] == '@'))
13936                     {
13937                       /* Allow crt1 branch to go via a toc adjusting
13938                          stub.  Other calls that never return could do
13939                          the same, if we could detect such.  */
13940                       can_plt_call = TRUE;
13941                     }
13942                 }
13943
13944               if (!can_plt_call)
13945                 {
13946                   /* g++ as of 20130507 emits self-calls without a
13947                      following nop.  This is arguably wrong since we
13948                      have conflicting information.  On the one hand a
13949                      global symbol and on the other a local call
13950                      sequence, but don't error for this special case.
13951                      It isn't possible to cheaply verify we have
13952                      exactly such a call.  Allow all calls to the same
13953                      section.  */
13954                   asection *code_sec = sec;
13955
13956                   if (get_opd_info (sec) != NULL)
13957                     {
13958                       bfd_vma off = (relocation + addend
13959                                      - sec->output_section->vma
13960                                      - sec->output_offset);
13961
13962                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13963                     }
13964                   if (code_sec == input_section)
13965                     can_plt_call = TRUE;
13966                 }
13967
13968               if (!can_plt_call)
13969                 {
13970                   if (stub_entry->stub_type == ppc_stub_plt_call
13971                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13972                     info->callbacks->einfo
13973                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13974                          "recompile with -fPIC\n"),
13975                        input_bfd, input_section, rel->r_offset, sym_name);
13976                   else
13977                     info->callbacks->einfo
13978                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13979                          "(-mcmodel=small toc adjust stub)\n"),
13980                        input_bfd, input_section, rel->r_offset, sym_name);
13981
13982                   bfd_set_error (bfd_error_bad_value);
13983                   ret = FALSE;
13984                 }
13985
13986               if (can_plt_call
13987                   && (stub_entry->stub_type == ppc_stub_plt_call
13988                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13989                 unresolved_reloc = FALSE;
13990             }
13991
13992           if ((stub_entry == NULL
13993                || stub_entry->stub_type == ppc_stub_long_branch
13994                || stub_entry->stub_type == ppc_stub_plt_branch)
13995               && get_opd_info (sec) != NULL)
13996             {
13997               /* The branch destination is the value of the opd entry. */
13998               bfd_vma off = (relocation + addend
13999                              - sec->output_section->vma
14000                              - sec->output_offset);
14001               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14002               if (dest != (bfd_vma) -1)
14003                 {
14004                   relocation = dest;
14005                   addend = 0;
14006                   reloc_dest = DEST_OPD;
14007                 }
14008             }
14009
14010           /* If the branch is out of reach we ought to have a long
14011              branch stub.  */
14012           from = (rel->r_offset
14013                   + input_section->output_offset
14014                   + input_section->output_section->vma);
14015
14016           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14017                                                   ? fdh->elf.other
14018                                                   : sym->st_other);
14019
14020           if (stub_entry != NULL
14021               && (stub_entry->stub_type == ppc_stub_long_branch
14022                   || stub_entry->stub_type == ppc_stub_plt_branch)
14023               && (r_type == R_PPC64_ADDR14_BRTAKEN
14024                   || r_type == R_PPC64_ADDR14_BRNTAKEN
14025                   || (relocation + addend - from + max_br_offset
14026                       < 2 * max_br_offset)))
14027             /* Don't use the stub if this branch is in range.  */
14028             stub_entry = NULL;
14029
14030           if (stub_entry != NULL)
14031             {
14032               /* Munge up the value and addend so that we call the stub
14033                  rather than the procedure directly.  */
14034               asection *stub_sec = stub_entry->group->stub_sec;
14035
14036               if (stub_entry->stub_type == ppc_stub_save_res)
14037                 relocation += (stub_sec->output_offset
14038                                + stub_sec->output_section->vma
14039                                + stub_sec->size - htab->sfpr->size
14040                                - htab->sfpr->output_offset
14041                                - htab->sfpr->output_section->vma);
14042               else
14043                 relocation = (stub_entry->stub_offset
14044                               + stub_sec->output_offset
14045                               + stub_sec->output_section->vma);
14046               addend = 0;
14047               reloc_dest = DEST_STUB;
14048
14049               if ((stub_entry->stub_type == ppc_stub_plt_call
14050                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14051                   && (ALWAYS_EMIT_R2SAVE
14052                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14053                   && rel + 1 < relend
14054                   && rel[1].r_offset == rel->r_offset + 4
14055                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14056                 relocation += 4;
14057             }
14058
14059           if (insn != 0)
14060             {
14061               if (is_isa_v2)
14062                 {
14063                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
14064                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
14065                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
14066                   if ((insn & (0x14 << 21)) == (0x04 << 21))
14067                     insn |= 0x02 << 21;
14068                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
14069                     insn |= 0x08 << 21;
14070                   else
14071                     break;
14072                 }
14073               else
14074                 {
14075                   /* Invert 'y' bit if not the default.  */
14076                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
14077                     insn ^= 0x01 << 21;
14078                 }
14079
14080               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14081             }
14082
14083           /* NOP out calls to undefined weak functions.
14084              We can thus call a weak function without first
14085              checking whether the function is defined.  */
14086           else if (h != NULL
14087                    && h->elf.root.type == bfd_link_hash_undefweak
14088                    && h->elf.dynindx == -1
14089                    && r_type == R_PPC64_REL24
14090                    && relocation == 0
14091                    && addend == 0)
14092             {
14093               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14094               continue;
14095             }
14096           break;
14097         }
14098
14099       /* Set `addend'.  */
14100       tls_type = 0;
14101       switch (r_type)
14102         {
14103         default:
14104           info->callbacks->einfo
14105             (_("%P: %B: unknown relocation type %d for `%T'\n"),
14106              input_bfd, (int) r_type, sym_name);
14107
14108           bfd_set_error (bfd_error_bad_value);
14109           ret = FALSE;
14110           continue;
14111
14112         case R_PPC64_NONE:
14113         case R_PPC64_TLS:
14114         case R_PPC64_TLSGD:
14115         case R_PPC64_TLSLD:
14116         case R_PPC64_TOCSAVE:
14117         case R_PPC64_GNU_VTINHERIT:
14118         case R_PPC64_GNU_VTENTRY:
14119           continue;
14120
14121           /* GOT16 relocations.  Like an ADDR16 using the symbol's
14122              address in the GOT as relocation value instead of the
14123              symbol's value itself.  Also, create a GOT entry for the
14124              symbol and put the symbol value there.  */
14125         case R_PPC64_GOT_TLSGD16:
14126         case R_PPC64_GOT_TLSGD16_LO:
14127         case R_PPC64_GOT_TLSGD16_HI:
14128         case R_PPC64_GOT_TLSGD16_HA:
14129           tls_type = TLS_TLS | TLS_GD;
14130           goto dogot;
14131
14132         case R_PPC64_GOT_TLSLD16:
14133         case R_PPC64_GOT_TLSLD16_LO:
14134         case R_PPC64_GOT_TLSLD16_HI:
14135         case R_PPC64_GOT_TLSLD16_HA:
14136           tls_type = TLS_TLS | TLS_LD;
14137           goto dogot;
14138
14139         case R_PPC64_GOT_TPREL16_DS:
14140         case R_PPC64_GOT_TPREL16_LO_DS:
14141         case R_PPC64_GOT_TPREL16_HI:
14142         case R_PPC64_GOT_TPREL16_HA:
14143           tls_type = TLS_TLS | TLS_TPREL;
14144           goto dogot;
14145
14146         case R_PPC64_GOT_DTPREL16_DS:
14147         case R_PPC64_GOT_DTPREL16_LO_DS:
14148         case R_PPC64_GOT_DTPREL16_HI:
14149         case R_PPC64_GOT_DTPREL16_HA:
14150           tls_type = TLS_TLS | TLS_DTPREL;
14151           goto dogot;
14152
14153         case R_PPC64_GOT16:
14154         case R_PPC64_GOT16_LO:
14155         case R_PPC64_GOT16_HI:
14156         case R_PPC64_GOT16_HA:
14157         case R_PPC64_GOT16_DS:
14158         case R_PPC64_GOT16_LO_DS:
14159         dogot:
14160           {
14161             /* Relocation is to the entry for this symbol in the global
14162                offset table.  */
14163             asection *got;
14164             bfd_vma *offp;
14165             bfd_vma off;
14166             unsigned long indx = 0;
14167             struct got_entry *ent;
14168
14169             if (tls_type == (TLS_TLS | TLS_LD)
14170                 && (h == NULL
14171                     || !h->elf.def_dynamic))
14172               ent = ppc64_tlsld_got (input_bfd);
14173             else
14174               {
14175
14176                 if (h != NULL)
14177                   {
14178                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
14179                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14180                                                           &h->elf)
14181                         || (bfd_link_pic (info)
14182                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14183                       /* This is actually a static link, or it is a
14184                          -Bsymbolic link and the symbol is defined
14185                          locally, or the symbol was forced to be local
14186                          because of a version file.  */
14187                       ;
14188                     else
14189                       {
14190                         BFD_ASSERT (h->elf.dynindx != -1);
14191                         indx = h->elf.dynindx;
14192                         unresolved_reloc = FALSE;
14193                       }
14194                     ent = h->elf.got.glist;
14195                   }
14196                 else
14197                   {
14198                     if (local_got_ents == NULL)
14199                       abort ();
14200                     ent = local_got_ents[r_symndx];
14201                   }
14202
14203                 for (; ent != NULL; ent = ent->next)
14204                   if (ent->addend == orig_rel.r_addend
14205                       && ent->owner == input_bfd
14206                       && ent->tls_type == tls_type)
14207                     break;
14208               }
14209
14210             if (ent == NULL)
14211               abort ();
14212             if (ent->is_indirect)
14213               ent = ent->got.ent;
14214             offp = &ent->got.offset;
14215             got = ppc64_elf_tdata (ent->owner)->got;
14216             if (got == NULL)
14217               abort ();
14218
14219             /* The offset must always be a multiple of 8.  We use the
14220                least significant bit to record whether we have already
14221                processed this entry.  */
14222             off = *offp;
14223             if ((off & 1) != 0)
14224               off &= ~1;
14225             else
14226               {
14227                 /* Generate relocs for the dynamic linker, except in
14228                    the case of TLSLD where we'll use one entry per
14229                    module.  */
14230                 asection *relgot;
14231                 bfd_boolean ifunc;
14232
14233                 *offp = off | 1;
14234                 relgot = NULL;
14235                 ifunc = (h != NULL
14236                          ? h->elf.type == STT_GNU_IFUNC
14237                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14238                 if (ifunc)
14239                   relgot = htab->elf.irelplt;
14240                 else if ((bfd_link_pic (info) || indx != 0)
14241                          && (h == NULL
14242                              || (tls_type == (TLS_TLS | TLS_LD)
14243                                  && !h->elf.def_dynamic)
14244                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14245                              || h->elf.root.type != bfd_link_hash_undefweak))
14246                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14247                 if (relgot != NULL)
14248                   {
14249                     outrel.r_offset = (got->output_section->vma
14250                                        + got->output_offset
14251                                        + off);
14252                     outrel.r_addend = addend;
14253                     if (tls_type & (TLS_LD | TLS_GD))
14254                       {
14255                         outrel.r_addend = 0;
14256                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14257                         if (tls_type == (TLS_TLS | TLS_GD))
14258                           {
14259                             loc = relgot->contents;
14260                             loc += (relgot->reloc_count++
14261                                     * sizeof (Elf64_External_Rela));
14262                             bfd_elf64_swap_reloca_out (output_bfd,
14263                                                        &outrel, loc);
14264                             outrel.r_offset += 8;
14265                             outrel.r_addend = addend;
14266                             outrel.r_info
14267                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14268                           }
14269                       }
14270                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14271                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14272                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14273                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14274                     else if (indx != 0)
14275                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14276                     else
14277                       {
14278                         if (ifunc)
14279                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14280                         else
14281                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14282
14283                         /* Write the .got section contents for the sake
14284                            of prelink.  */
14285                         loc = got->contents + off;
14286                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14287                                     loc);
14288                       }
14289
14290                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14291                       {
14292                         outrel.r_addend += relocation;
14293                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14294                           {
14295                             if (htab->elf.tls_sec == NULL)
14296                               outrel.r_addend = 0;
14297                             else
14298                               outrel.r_addend -= htab->elf.tls_sec->vma;
14299                           }
14300                       }
14301                     loc = relgot->contents;
14302                     loc += (relgot->reloc_count++
14303                             * sizeof (Elf64_External_Rela));
14304                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14305                   }
14306
14307                 /* Init the .got section contents here if we're not
14308                    emitting a reloc.  */
14309                 else
14310                   {
14311                     relocation += addend;
14312                     if (tls_type == (TLS_TLS | TLS_LD))
14313                       relocation = 1;
14314                     else if (tls_type != 0)
14315                       {
14316                         if (htab->elf.tls_sec == NULL)
14317                           relocation = 0;
14318                         else
14319                           {
14320                             relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14321                             if (tls_type == (TLS_TLS | TLS_TPREL))
14322                               relocation += DTP_OFFSET - TP_OFFSET;
14323                           }
14324
14325                         if (tls_type == (TLS_TLS | TLS_GD))
14326                           {
14327                             bfd_put_64 (output_bfd, relocation,
14328                                         got->contents + off + 8);
14329                             relocation = 1;
14330                           }
14331                       }
14332
14333                     bfd_put_64 (output_bfd, relocation,
14334                                 got->contents + off);
14335                   }
14336               }
14337
14338             if (off >= (bfd_vma) -2)
14339               abort ();
14340
14341             relocation = got->output_section->vma + got->output_offset + off;
14342             addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14343           }
14344           break;
14345
14346         case R_PPC64_PLT16_HA:
14347         case R_PPC64_PLT16_HI:
14348         case R_PPC64_PLT16_LO:
14349         case R_PPC64_PLT32:
14350         case R_PPC64_PLT64:
14351           /* Relocation is to the entry for this symbol in the
14352              procedure linkage table.  */
14353
14354           /* Resolve a PLT reloc against a local symbol directly,
14355              without using the procedure linkage table.  */
14356           if (h == NULL)
14357             break;
14358
14359           /* It's possible that we didn't make a PLT entry for this
14360              symbol.  This happens when statically linking PIC code,
14361              or when using -Bsymbolic.  Go find a match if there is a
14362              PLT entry.  */
14363           if (htab->elf.splt != NULL)
14364             {
14365               struct plt_entry *ent;
14366               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14367                 if (ent->plt.offset != (bfd_vma) -1
14368                     && ent->addend == orig_rel.r_addend)
14369                   {
14370                     relocation = (htab->elf.splt->output_section->vma
14371                                   + htab->elf.splt->output_offset
14372                                   + ent->plt.offset);
14373                     unresolved_reloc = FALSE;
14374                     break;
14375                   }
14376             }
14377           break;
14378
14379         case R_PPC64_TOC:
14380           /* Relocation value is TOC base.  */
14381           relocation = TOCstart;
14382           if (r_symndx == STN_UNDEF)
14383             relocation += htab->sec_info[input_section->id].toc_off;
14384           else if (unresolved_reloc)
14385             ;
14386           else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14387             relocation += htab->sec_info[sec->id].toc_off;
14388           else
14389             unresolved_reloc = TRUE;
14390           goto dodyn;
14391
14392           /* TOC16 relocs.  We want the offset relative to the TOC base,
14393              which is the address of the start of the TOC plus 0x8000.
14394              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14395              in this order.  */
14396         case R_PPC64_TOC16:
14397         case R_PPC64_TOC16_LO:
14398         case R_PPC64_TOC16_HI:
14399         case R_PPC64_TOC16_DS:
14400         case R_PPC64_TOC16_LO_DS:
14401         case R_PPC64_TOC16_HA:
14402           addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14403           break;
14404
14405           /* Relocate against the beginning of the section.  */
14406         case R_PPC64_SECTOFF:
14407         case R_PPC64_SECTOFF_LO:
14408         case R_PPC64_SECTOFF_HI:
14409         case R_PPC64_SECTOFF_DS:
14410         case R_PPC64_SECTOFF_LO_DS:
14411         case R_PPC64_SECTOFF_HA:
14412           if (sec != NULL)
14413             addend -= sec->output_section->vma;
14414           break;
14415
14416         case R_PPC64_REL16:
14417         case R_PPC64_REL16_LO:
14418         case R_PPC64_REL16_HI:
14419         case R_PPC64_REL16_HA:
14420           break;
14421
14422         case R_PPC64_REL14:
14423         case R_PPC64_REL14_BRNTAKEN:
14424         case R_PPC64_REL14_BRTAKEN:
14425         case R_PPC64_REL24:
14426           break;
14427
14428         case R_PPC64_TPREL16:
14429         case R_PPC64_TPREL16_LO:
14430         case R_PPC64_TPREL16_HI:
14431         case R_PPC64_TPREL16_HA:
14432         case R_PPC64_TPREL16_DS:
14433         case R_PPC64_TPREL16_LO_DS:
14434         case R_PPC64_TPREL16_HIGH:
14435         case R_PPC64_TPREL16_HIGHA:
14436         case R_PPC64_TPREL16_HIGHER:
14437         case R_PPC64_TPREL16_HIGHERA:
14438         case R_PPC64_TPREL16_HIGHEST:
14439         case R_PPC64_TPREL16_HIGHESTA:
14440           if (h != NULL
14441               && h->elf.root.type == bfd_link_hash_undefweak
14442               && h->elf.dynindx == -1)
14443             {
14444               /* Make this relocation against an undefined weak symbol
14445                  resolve to zero.  This is really just a tweak, since
14446                  code using weak externs ought to check that they are
14447                  defined before using them.  */
14448               bfd_byte *p = contents + rel->r_offset - d_offset;
14449
14450               insn = bfd_get_32 (output_bfd, p);
14451               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14452               if (insn != 0)
14453                 bfd_put_32 (output_bfd, insn, p);
14454               break;
14455             }
14456           if (htab->elf.tls_sec != NULL)
14457             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14458           if (bfd_link_pic (info))
14459             /* The TPREL16 relocs shouldn't really be used in shared
14460                libs as they will result in DT_TEXTREL being set, but
14461                support them anyway.  */
14462             goto dodyn;
14463           break;
14464
14465         case R_PPC64_DTPREL16:
14466         case R_PPC64_DTPREL16_LO:
14467         case R_PPC64_DTPREL16_HI:
14468         case R_PPC64_DTPREL16_HA:
14469         case R_PPC64_DTPREL16_DS:
14470         case R_PPC64_DTPREL16_LO_DS:
14471         case R_PPC64_DTPREL16_HIGH:
14472         case R_PPC64_DTPREL16_HIGHA:
14473         case R_PPC64_DTPREL16_HIGHER:
14474         case R_PPC64_DTPREL16_HIGHERA:
14475         case R_PPC64_DTPREL16_HIGHEST:
14476         case R_PPC64_DTPREL16_HIGHESTA:
14477           if (htab->elf.tls_sec != NULL)
14478             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14479           break;
14480
14481         case R_PPC64_ADDR64_LOCAL:
14482           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14483                                               ? h->elf.other
14484                                               : sym->st_other);
14485           break;
14486
14487         case R_PPC64_DTPMOD64:
14488           relocation = 1;
14489           addend = 0;
14490           goto dodyn;
14491
14492         case R_PPC64_TPREL64:
14493           if (htab->elf.tls_sec != NULL)
14494             addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14495           goto dodyn;
14496
14497         case R_PPC64_DTPREL64:
14498           if (htab->elf.tls_sec != NULL)
14499             addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14500           /* Fall thru */
14501
14502           /* Relocations that may need to be propagated if this is a
14503              dynamic object.  */
14504         case R_PPC64_REL30:
14505         case R_PPC64_REL32:
14506         case R_PPC64_REL64:
14507         case R_PPC64_ADDR14:
14508         case R_PPC64_ADDR14_BRNTAKEN:
14509         case R_PPC64_ADDR14_BRTAKEN:
14510         case R_PPC64_ADDR16:
14511         case R_PPC64_ADDR16_DS:
14512         case R_PPC64_ADDR16_HA:
14513         case R_PPC64_ADDR16_HI:
14514         case R_PPC64_ADDR16_HIGH:
14515         case R_PPC64_ADDR16_HIGHA:
14516         case R_PPC64_ADDR16_HIGHER:
14517         case R_PPC64_ADDR16_HIGHERA:
14518         case R_PPC64_ADDR16_HIGHEST:
14519         case R_PPC64_ADDR16_HIGHESTA:
14520         case R_PPC64_ADDR16_LO:
14521         case R_PPC64_ADDR16_LO_DS:
14522         case R_PPC64_ADDR24:
14523         case R_PPC64_ADDR32:
14524         case R_PPC64_ADDR64:
14525         case R_PPC64_UADDR16:
14526         case R_PPC64_UADDR32:
14527         case R_PPC64_UADDR64:
14528         dodyn:
14529           if ((input_section->flags & SEC_ALLOC) == 0)
14530             break;
14531
14532           if (NO_OPD_RELOCS && is_opd)
14533             break;
14534
14535           if ((bfd_link_pic (info)
14536                && (h == NULL
14537                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14538                    || h->elf.root.type != bfd_link_hash_undefweak)
14539                && (must_be_dyn_reloc (info, r_type)
14540                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14541               || (ELIMINATE_COPY_RELOCS
14542                   && !bfd_link_pic (info)
14543                   && h != NULL
14544                   && h->elf.dynindx != -1
14545                   && !h->elf.non_got_ref
14546                   && !h->elf.def_regular)
14547               || (!bfd_link_pic (info)
14548                   && (h != NULL
14549                       ? h->elf.type == STT_GNU_IFUNC
14550                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14551             {
14552               bfd_boolean skip, relocate;
14553               asection *sreloc;
14554               bfd_vma out_off;
14555
14556               /* When generating a dynamic object, these relocations
14557                  are copied into the output file to be resolved at run
14558                  time.  */
14559
14560               skip = FALSE;
14561               relocate = FALSE;
14562
14563               out_off = _bfd_elf_section_offset (output_bfd, info,
14564                                                  input_section, rel->r_offset);
14565               if (out_off == (bfd_vma) -1)
14566                 skip = TRUE;
14567               else if (out_off == (bfd_vma) -2)
14568                 skip = TRUE, relocate = TRUE;
14569               out_off += (input_section->output_section->vma
14570                           + input_section->output_offset);
14571               outrel.r_offset = out_off;
14572               outrel.r_addend = rel->r_addend;
14573
14574               /* Optimize unaligned reloc use.  */
14575               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14576                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14577                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14578               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14579                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14580                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14581               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14582                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14583                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14584
14585               if (skip)
14586                 memset (&outrel, 0, sizeof outrel);
14587               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14588                        && !is_opd
14589                        && r_type != R_PPC64_TOC)
14590                 {
14591                   BFD_ASSERT (h->elf.dynindx != -1);
14592                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14593                 }
14594               else
14595                 {
14596                   /* This symbol is local, or marked to become local,
14597                      or this is an opd section reloc which must point
14598                      at a local function.  */
14599                   outrel.r_addend += relocation;
14600                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14601                     {
14602                       if (is_opd && h != NULL)
14603                         {
14604                           /* Lie about opd entries.  This case occurs
14605                              when building shared libraries and we
14606                              reference a function in another shared
14607                              lib.  The same thing happens for a weak
14608                              definition in an application that's
14609                              overridden by a strong definition in a
14610                              shared lib.  (I believe this is a generic
14611                              bug in binutils handling of weak syms.)
14612                              In these cases we won't use the opd
14613                              entry in this lib.  */
14614                           unresolved_reloc = FALSE;
14615                         }
14616                       if (!is_opd
14617                           && r_type == R_PPC64_ADDR64
14618                           && (h != NULL
14619                               ? h->elf.type == STT_GNU_IFUNC
14620                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14621                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14622                       else
14623                         {
14624                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14625
14626                           /* We need to relocate .opd contents for ld.so.
14627                              Prelink also wants simple and consistent rules
14628                              for relocs.  This make all RELATIVE relocs have
14629                              *r_offset equal to r_addend.  */
14630                           relocate = TRUE;
14631                         }
14632                     }
14633                   else
14634                     {
14635                       long indx = 0;
14636
14637                       if (h != NULL
14638                           ? h->elf.type == STT_GNU_IFUNC
14639                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14640                         {
14641                           info->callbacks->einfo
14642                             (_("%P: %H: %s for indirect "
14643                                "function `%T' unsupported\n"),
14644                              input_bfd, input_section, rel->r_offset,
14645                              ppc64_elf_howto_table[r_type]->name,
14646                              sym_name);
14647                           ret = FALSE;
14648                         }
14649                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14650                         ;
14651                       else if (sec == NULL || sec->owner == NULL)
14652                         {
14653                           bfd_set_error (bfd_error_bad_value);
14654                           return FALSE;
14655                         }
14656                       else
14657                         {
14658                           asection *osec;
14659
14660                           osec = sec->output_section;
14661                           indx = elf_section_data (osec)->dynindx;
14662
14663                           if (indx == 0)
14664                             {
14665                               if ((osec->flags & SEC_READONLY) == 0
14666                                   && htab->elf.data_index_section != NULL)
14667                                 osec = htab->elf.data_index_section;
14668                               else
14669                                 osec = htab->elf.text_index_section;
14670                               indx = elf_section_data (osec)->dynindx;
14671                             }
14672                           BFD_ASSERT (indx != 0);
14673
14674                           /* We are turning this relocation into one
14675                              against a section symbol, so subtract out
14676                              the output section's address but not the
14677                              offset of the input section in the output
14678                              section.  */
14679                           outrel.r_addend -= osec->vma;
14680                         }
14681
14682                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14683                     }
14684                 }
14685
14686               sreloc = elf_section_data (input_section)->sreloc;
14687               if (h != NULL
14688                   ? h->elf.type == STT_GNU_IFUNC
14689                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14690                 sreloc = htab->elf.irelplt;
14691               if (sreloc == NULL)
14692                 abort ();
14693
14694               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14695                   >= sreloc->size)
14696                 abort ();
14697               loc = sreloc->contents;
14698               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14699               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14700
14701               /* If this reloc is against an external symbol, it will
14702                  be computed at runtime, so there's no need to do
14703                  anything now.  However, for the sake of prelink ensure
14704                  that the section contents are a known value.  */
14705               if (! relocate)
14706                 {
14707                   unresolved_reloc = FALSE;
14708                   /* The value chosen here is quite arbitrary as ld.so
14709                      ignores section contents except for the special
14710                      case of .opd where the contents might be accessed
14711                      before relocation.  Choose zero, as that won't
14712                      cause reloc overflow.  */
14713                   relocation = 0;
14714                   addend = 0;
14715                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14716                      to improve backward compatibility with older
14717                      versions of ld.  */
14718                   if (r_type == R_PPC64_ADDR64)
14719                     addend = outrel.r_addend;
14720                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14721                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14722                     addend = (input_section->output_section->vma
14723                               + input_section->output_offset
14724                               + rel->r_offset);
14725                 }
14726             }
14727           break;
14728
14729         case R_PPC64_COPY:
14730         case R_PPC64_GLOB_DAT:
14731         case R_PPC64_JMP_SLOT:
14732         case R_PPC64_JMP_IREL:
14733         case R_PPC64_RELATIVE:
14734           /* We shouldn't ever see these dynamic relocs in relocatable
14735              files.  */
14736           /* Fall through.  */
14737
14738         case R_PPC64_PLTGOT16:
14739         case R_PPC64_PLTGOT16_DS:
14740         case R_PPC64_PLTGOT16_HA:
14741         case R_PPC64_PLTGOT16_HI:
14742         case R_PPC64_PLTGOT16_LO:
14743         case R_PPC64_PLTGOT16_LO_DS:
14744         case R_PPC64_PLTREL32:
14745         case R_PPC64_PLTREL64:
14746           /* These ones haven't been implemented yet.  */
14747
14748           info->callbacks->einfo
14749             (_("%P: %B: %s is not supported for `%T'\n"),
14750              input_bfd,
14751              ppc64_elf_howto_table[r_type]->name, sym_name);
14752
14753           bfd_set_error (bfd_error_invalid_operation);
14754           ret = FALSE;
14755           continue;
14756         }
14757
14758       /* Multi-instruction sequences that access the TOC can be
14759          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14760          to             nop;           addi rb,r2,x;  */
14761       switch (r_type)
14762         {
14763         default:
14764           break;
14765
14766         case R_PPC64_GOT_TLSLD16_HI:
14767         case R_PPC64_GOT_TLSGD16_HI:
14768         case R_PPC64_GOT_TPREL16_HI:
14769         case R_PPC64_GOT_DTPREL16_HI:
14770         case R_PPC64_GOT16_HI:
14771         case R_PPC64_TOC16_HI:
14772           /* These relocs would only be useful if building up an
14773              offset to later add to r2, perhaps in an indexed
14774              addressing mode instruction.  Don't try to optimize.
14775              Unfortunately, the possibility of someone building up an
14776              offset like this or even with the HA relocs, means that
14777              we need to check the high insn when optimizing the low
14778              insn.  */
14779           break;
14780
14781         case R_PPC64_GOT_TLSLD16_HA:
14782         case R_PPC64_GOT_TLSGD16_HA:
14783         case R_PPC64_GOT_TPREL16_HA:
14784         case R_PPC64_GOT_DTPREL16_HA:
14785         case R_PPC64_GOT16_HA:
14786         case R_PPC64_TOC16_HA:
14787           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14788               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14789             {
14790               bfd_byte *p = contents + (rel->r_offset & ~3);
14791               bfd_put_32 (input_bfd, NOP, p);
14792             }
14793           break;
14794
14795         case R_PPC64_GOT_TLSLD16_LO:
14796         case R_PPC64_GOT_TLSGD16_LO:
14797         case R_PPC64_GOT_TPREL16_LO_DS:
14798         case R_PPC64_GOT_DTPREL16_LO_DS:
14799         case R_PPC64_GOT16_LO:
14800         case R_PPC64_GOT16_LO_DS:
14801         case R_PPC64_TOC16_LO:
14802         case R_PPC64_TOC16_LO_DS:
14803           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14804               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14805             {
14806               bfd_byte *p = contents + (rel->r_offset & ~3);
14807               insn = bfd_get_32 (input_bfd, p);
14808               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14809                 {
14810                   /* Transform addic to addi when we change reg.  */
14811                   insn &= ~((0x3f << 26) | (0x1f << 16));
14812                   insn |= (14u << 26) | (2 << 16);
14813                 }
14814               else
14815                 {
14816                   insn &= ~(0x1f << 16);
14817                   insn |= 2 << 16;
14818                 }
14819               bfd_put_32 (input_bfd, insn, p);
14820             }
14821           break;
14822         }
14823
14824       /* Do any further special processing.  */
14825       howto = ppc64_elf_howto_table[(int) r_type];
14826       switch (r_type)
14827         {
14828         default:
14829           break;
14830
14831         case R_PPC64_REL16_HA:
14832         case R_PPC64_ADDR16_HA:
14833         case R_PPC64_ADDR16_HIGHA:
14834         case R_PPC64_ADDR16_HIGHERA:
14835         case R_PPC64_ADDR16_HIGHESTA:
14836         case R_PPC64_TOC16_HA:
14837         case R_PPC64_SECTOFF_HA:
14838         case R_PPC64_TPREL16_HA:
14839         case R_PPC64_TPREL16_HIGHA:
14840         case R_PPC64_TPREL16_HIGHERA:
14841         case R_PPC64_TPREL16_HIGHESTA:
14842         case R_PPC64_DTPREL16_HA:
14843         case R_PPC64_DTPREL16_HIGHA:
14844         case R_PPC64_DTPREL16_HIGHERA:
14845         case R_PPC64_DTPREL16_HIGHESTA:
14846           /* It's just possible that this symbol is a weak symbol
14847              that's not actually defined anywhere. In that case,
14848              'sec' would be NULL, and we should leave the symbol
14849              alone (it will be set to zero elsewhere in the link).  */
14850           if (sec == NULL)
14851             break;
14852           /* Fall thru */
14853
14854         case R_PPC64_GOT16_HA:
14855         case R_PPC64_PLTGOT16_HA:
14856         case R_PPC64_PLT16_HA:
14857         case R_PPC64_GOT_TLSGD16_HA:
14858         case R_PPC64_GOT_TLSLD16_HA:
14859         case R_PPC64_GOT_TPREL16_HA:
14860         case R_PPC64_GOT_DTPREL16_HA:
14861           /* Add 0x10000 if sign bit in 0:15 is set.
14862              Bits 0:15 are not used.  */
14863           addend += 0x8000;
14864           break;
14865
14866         case R_PPC64_ADDR16_DS:
14867         case R_PPC64_ADDR16_LO_DS:
14868         case R_PPC64_GOT16_DS:
14869         case R_PPC64_GOT16_LO_DS:
14870         case R_PPC64_PLT16_LO_DS:
14871         case R_PPC64_SECTOFF_DS:
14872         case R_PPC64_SECTOFF_LO_DS:
14873         case R_PPC64_TOC16_DS:
14874         case R_PPC64_TOC16_LO_DS:
14875         case R_PPC64_PLTGOT16_DS:
14876         case R_PPC64_PLTGOT16_LO_DS:
14877         case R_PPC64_GOT_TPREL16_DS:
14878         case R_PPC64_GOT_TPREL16_LO_DS:
14879         case R_PPC64_GOT_DTPREL16_DS:
14880         case R_PPC64_GOT_DTPREL16_LO_DS:
14881         case R_PPC64_TPREL16_DS:
14882         case R_PPC64_TPREL16_LO_DS:
14883         case R_PPC64_DTPREL16_DS:
14884         case R_PPC64_DTPREL16_LO_DS:
14885           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14886           mask = 3;
14887           /* If this reloc is against an lq insn, then the value must be
14888              a multiple of 16.  This is somewhat of a hack, but the
14889              "correct" way to do this by defining _DQ forms of all the
14890              _DS relocs bloats all reloc switches in this file.  It
14891              doesn't seem to make much sense to use any of these relocs
14892              in data, so testing the insn should be safe.  */
14893           if ((insn & (0x3f << 26)) == (56u << 26))
14894             mask = 15;
14895           if (((relocation + addend) & mask) != 0)
14896             {
14897               info->callbacks->einfo
14898                 (_("%P: %H: error: %s not a multiple of %u\n"),
14899                  input_bfd, input_section, rel->r_offset,
14900                  howto->name,
14901                  mask + 1);
14902               bfd_set_error (bfd_error_bad_value);
14903               ret = FALSE;
14904               continue;
14905             }
14906           break;
14907         }
14908
14909       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14910          because such sections are not SEC_ALLOC and thus ld.so will
14911          not process them.  */
14912       if (unresolved_reloc
14913           && !((input_section->flags & SEC_DEBUGGING) != 0
14914                && h->elf.def_dynamic)
14915           && _bfd_elf_section_offset (output_bfd, info, input_section,
14916                                       rel->r_offset) != (bfd_vma) -1)
14917         {
14918           info->callbacks->einfo
14919             (_("%P: %H: unresolvable %s against `%T'\n"),
14920              input_bfd, input_section, rel->r_offset,
14921              howto->name,
14922              h->elf.root.root.string);
14923           ret = FALSE;
14924         }
14925
14926       /* 16-bit fields in insns mostly have signed values, but a
14927          few insns have 16-bit unsigned values.  Really, we should
14928          have different reloc types.  */
14929       if (howto->complain_on_overflow != complain_overflow_dont
14930           && howto->dst_mask == 0xffff
14931           && (input_section->flags & SEC_CODE) != 0)
14932         {
14933           enum complain_overflow complain = complain_overflow_signed;
14934
14935           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14936           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14937             complain = complain_overflow_bitfield;
14938           else if (howto->rightshift == 0
14939                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14940                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14941                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14942                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14943                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14944                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14945             complain = complain_overflow_unsigned;
14946           if (howto->complain_on_overflow != complain)
14947             {
14948               alt_howto = *howto;
14949               alt_howto.complain_on_overflow = complain;
14950               howto = &alt_howto;
14951             }
14952         }
14953
14954       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14955                                     rel->r_offset, relocation, addend);
14956
14957       if (r != bfd_reloc_ok)
14958         {
14959           char *more_info = NULL;
14960           const char *reloc_name = howto->name;
14961
14962           if (reloc_dest != DEST_NORMAL)
14963             {
14964               more_info = bfd_malloc (strlen (reloc_name) + 8);
14965               if (more_info != NULL)
14966                 {
14967                   strcpy (more_info, reloc_name);
14968                   strcat (more_info, (reloc_dest == DEST_OPD
14969                                       ? " (OPD)" : " (stub)"));
14970                   reloc_name = more_info;
14971                 }
14972             }
14973
14974           if (r == bfd_reloc_overflow)
14975             {
14976               /* On code like "if (foo) foo();" don't report overflow
14977                  on a branch to zero when foo is undefined.  */
14978               if (!warned
14979                   && (reloc_dest == DEST_STUB
14980                       || !(h != NULL
14981                            && (h->elf.root.type == bfd_link_hash_undefweak
14982                                || h->elf.root.type == bfd_link_hash_undefined)
14983                            && is_branch_reloc (r_type))))
14984                 {
14985                   if (!((*info->callbacks->reloc_overflow)
14986                         (info, &h->elf.root, sym_name,
14987                          reloc_name, orig_rel.r_addend,
14988                          input_bfd, input_section, rel->r_offset)))
14989                     return FALSE;
14990                 }
14991             }
14992           else
14993             {
14994               info->callbacks->einfo
14995                 (_("%P: %H: %s against `%T': error %d\n"),
14996                  input_bfd, input_section, rel->r_offset,
14997                  reloc_name, sym_name, (int) r);
14998               ret = FALSE;
14999             }
15000           if (more_info != NULL)
15001             free (more_info);
15002         }
15003     }
15004
15005   /* If we're emitting relocations, then shortly after this function
15006      returns, reloc offsets and addends for this section will be
15007      adjusted.  Worse, reloc symbol indices will be for the output
15008      file rather than the input.  Save a copy of the relocs for
15009      opd_entry_value.  */
15010   if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15011     {
15012       bfd_size_type amt;
15013       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15014       rel = bfd_alloc (input_bfd, amt);
15015       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15016       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15017       if (rel == NULL)
15018         return FALSE;
15019       memcpy (rel, relocs, amt);
15020     }
15021   return ret;
15022 }
15023
15024 /* Adjust the value of any local symbols in opd sections.  */
15025
15026 static int
15027 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15028                               const char *name ATTRIBUTE_UNUSED,
15029                               Elf_Internal_Sym *elfsym,
15030                               asection *input_sec,
15031                               struct elf_link_hash_entry *h)
15032 {
15033   struct _opd_sec_data *opd;
15034   long adjust;
15035   bfd_vma value;
15036
15037   if (h != NULL)
15038     return 1;
15039
15040   opd = get_opd_info (input_sec);
15041   if (opd == NULL || opd->adjust == NULL)
15042     return 1;
15043
15044   value = elfsym->st_value - input_sec->output_offset;
15045   if (!bfd_link_relocatable (info))
15046     value -= input_sec->output_section->vma;
15047
15048   adjust = opd->adjust[OPD_NDX (value)];
15049   if (adjust == -1)
15050     return 2;
15051
15052   elfsym->st_value += adjust;
15053   return 1;
15054 }
15055
15056 /* Finish up dynamic symbol handling.  We set the contents of various
15057    dynamic sections here.  */
15058
15059 static bfd_boolean
15060 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15061                                  struct bfd_link_info *info,
15062                                  struct elf_link_hash_entry *h,
15063                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15064 {
15065   struct ppc_link_hash_table *htab;
15066   struct plt_entry *ent;
15067   Elf_Internal_Rela rela;
15068   bfd_byte *loc;
15069
15070   htab = ppc_hash_table (info);
15071   if (htab == NULL)
15072     return FALSE;
15073
15074   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15075     if (ent->plt.offset != (bfd_vma) -1)
15076       {
15077         /* This symbol has an entry in the procedure linkage
15078            table.  Set it up.  */
15079         if (!htab->elf.dynamic_sections_created
15080             || h->dynindx == -1)
15081           {
15082             BFD_ASSERT (h->type == STT_GNU_IFUNC
15083                         && h->def_regular
15084                         && (h->root.type == bfd_link_hash_defined
15085                             || h->root.type == bfd_link_hash_defweak));
15086             rela.r_offset = (htab->elf.iplt->output_section->vma
15087                              + htab->elf.iplt->output_offset
15088                              + ent->plt.offset);
15089             if (htab->opd_abi)
15090               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15091             else
15092               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15093             rela.r_addend = (h->root.u.def.value
15094                              + h->root.u.def.section->output_offset
15095                              + h->root.u.def.section->output_section->vma
15096                              + ent->addend);
15097             loc = (htab->elf.irelplt->contents
15098                    + (htab->elf.irelplt->reloc_count++
15099                       * sizeof (Elf64_External_Rela)));
15100           }
15101         else
15102           {
15103             rela.r_offset = (htab->elf.splt->output_section->vma
15104                              + htab->elf.splt->output_offset
15105                              + ent->plt.offset);
15106             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15107             rela.r_addend = ent->addend;
15108             loc = (htab->elf.srelplt->contents
15109                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15110                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15111           }
15112         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15113
15114         if (!htab->opd_abi)
15115           {
15116             if (!h->def_regular)
15117               {
15118                 /* Mark the symbol as undefined, rather than as
15119                    defined in glink.  Leave the value if there were
15120                    any relocations where pointer equality matters
15121                    (this is a clue for the dynamic linker, to make
15122                    function pointer comparisons work between an
15123                    application and shared library), otherwise set it
15124                    to zero.  */
15125                 sym->st_shndx = SHN_UNDEF;
15126                 if (!h->pointer_equality_needed)
15127                   sym->st_value = 0;
15128                 else if (!h->ref_regular_nonweak)
15129                   {
15130                     /* This breaks function pointer comparisons, but
15131                        that is better than breaking tests for a NULL
15132                        function pointer.  */
15133                     sym->st_value = 0;
15134                   }
15135               }
15136           }
15137       }
15138
15139   if (h->needs_copy)
15140     {
15141       /* This symbol needs a copy reloc.  Set it up.  */
15142
15143       if (h->dynindx == -1
15144           || (h->root.type != bfd_link_hash_defined
15145               && h->root.type != bfd_link_hash_defweak)
15146           || htab->relbss == NULL)
15147         abort ();
15148
15149       rela.r_offset = (h->root.u.def.value
15150                        + h->root.u.def.section->output_section->vma
15151                        + h->root.u.def.section->output_offset);
15152       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15153       rela.r_addend = 0;
15154       loc = htab->relbss->contents;
15155       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15156       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15157     }
15158
15159   return TRUE;
15160 }
15161
15162 /* Used to decide how to sort relocs in an optimal manner for the
15163    dynamic linker, before writing them out.  */
15164
15165 static enum elf_reloc_type_class
15166 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15167                             const asection *rel_sec,
15168                             const Elf_Internal_Rela *rela)
15169 {
15170   enum elf_ppc64_reloc_type r_type;
15171   struct ppc_link_hash_table *htab = ppc_hash_table (info);
15172
15173   if (rel_sec == htab->elf.irelplt)
15174     return reloc_class_ifunc;
15175
15176   r_type = ELF64_R_TYPE (rela->r_info);
15177   switch (r_type)
15178     {
15179     case R_PPC64_RELATIVE:
15180       return reloc_class_relative;
15181     case R_PPC64_JMP_SLOT:
15182       return reloc_class_plt;
15183     case R_PPC64_COPY:
15184       return reloc_class_copy;
15185     default:
15186       return reloc_class_normal;
15187     }
15188 }
15189
15190 /* Finish up the dynamic sections.  */
15191
15192 static bfd_boolean
15193 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15194                                    struct bfd_link_info *info)
15195 {
15196   struct ppc_link_hash_table *htab;
15197   bfd *dynobj;
15198   asection *sdyn;
15199
15200   htab = ppc_hash_table (info);
15201   if (htab == NULL)
15202     return FALSE;
15203
15204   dynobj = htab->elf.dynobj;
15205   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15206
15207   if (htab->elf.dynamic_sections_created)
15208     {
15209       Elf64_External_Dyn *dyncon, *dynconend;
15210
15211       if (sdyn == NULL || htab->elf.sgot == NULL)
15212         abort ();
15213
15214       dyncon = (Elf64_External_Dyn *) sdyn->contents;
15215       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15216       for (; dyncon < dynconend; dyncon++)
15217         {
15218           Elf_Internal_Dyn dyn;
15219           asection *s;
15220
15221           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15222
15223           switch (dyn.d_tag)
15224             {
15225             default:
15226               continue;
15227
15228             case DT_PPC64_GLINK:
15229               s = htab->glink;
15230               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15231               /* We stupidly defined DT_PPC64_GLINK to be the start
15232                  of glink rather than the first entry point, which is
15233                  what ld.so needs, and now have a bigger stub to
15234                  support automatic multiple TOCs.  */
15235               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15236               break;
15237
15238             case DT_PPC64_OPD:
15239               s = bfd_get_section_by_name (output_bfd, ".opd");
15240               if (s == NULL)
15241                 continue;
15242               dyn.d_un.d_ptr = s->vma;
15243               break;
15244
15245             case DT_PPC64_OPT:
15246               if (htab->do_multi_toc && htab->multi_toc_needed)
15247                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15248               break;
15249
15250             case DT_PPC64_OPDSZ:
15251               s = bfd_get_section_by_name (output_bfd, ".opd");
15252               if (s == NULL)
15253                 continue;
15254               dyn.d_un.d_val = s->size;
15255               break;
15256
15257             case DT_PLTGOT:
15258               s = htab->elf.splt;
15259               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15260               break;
15261
15262             case DT_JMPREL:
15263               s = htab->elf.srelplt;
15264               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15265               break;
15266
15267             case DT_PLTRELSZ:
15268               dyn.d_un.d_val = htab->elf.srelplt->size;
15269               break;
15270
15271             case DT_RELASZ:
15272               /* Don't count procedure linkage table relocs in the
15273                  overall reloc count.  */
15274               s = htab->elf.srelplt;
15275               if (s == NULL)
15276                 continue;
15277               dyn.d_un.d_val -= s->size;
15278               break;
15279
15280             case DT_RELA:
15281               /* We may not be using the standard ELF linker script.
15282                  If .rela.plt is the first .rela section, we adjust
15283                  DT_RELA to not include it.  */
15284               s = htab->elf.srelplt;
15285               if (s == NULL)
15286                 continue;
15287               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15288                 continue;
15289               dyn.d_un.d_ptr += s->size;
15290               break;
15291             }
15292
15293           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15294         }
15295     }
15296
15297   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15298     {
15299       /* Fill in the first entry in the global offset table.
15300          We use it to hold the link-time TOCbase.  */
15301       bfd_put_64 (output_bfd,
15302                   elf_gp (output_bfd) + TOC_BASE_OFF,
15303                   htab->elf.sgot->contents);
15304
15305       /* Set .got entry size.  */
15306       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15307     }
15308
15309   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15310     {
15311       /* Set .plt entry size.  */
15312       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15313         = PLT_ENTRY_SIZE (htab);
15314     }
15315
15316   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15317      brlt ourselves if emitrelocations.  */
15318   if (htab->brlt != NULL
15319       && htab->brlt->reloc_count != 0
15320       && !_bfd_elf_link_output_relocs (output_bfd,
15321                                        htab->brlt,
15322                                        elf_section_data (htab->brlt)->rela.hdr,
15323                                        elf_section_data (htab->brlt)->relocs,
15324                                        NULL))
15325     return FALSE;
15326
15327   if (htab->glink != NULL
15328       && htab->glink->reloc_count != 0
15329       && !_bfd_elf_link_output_relocs (output_bfd,
15330                                        htab->glink,
15331                                        elf_section_data (htab->glink)->rela.hdr,
15332                                        elf_section_data (htab->glink)->relocs,
15333                                        NULL))
15334     return FALSE;
15335
15336   if (htab->glink_eh_frame != NULL
15337       && htab->glink_eh_frame->size != 0)
15338     {
15339       bfd_vma val;
15340       bfd_byte *p;
15341       asection *stub_sec;
15342
15343       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15344       for (stub_sec = htab->params->stub_bfd->sections;
15345            stub_sec != NULL;
15346            stub_sec = stub_sec->next)
15347         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15348           {
15349             /* FDE length.  */
15350             p += 4;
15351             /* CIE pointer.  */
15352             p += 4;
15353             /* Offset to stub section.  */
15354             val = (stub_sec->output_section->vma
15355                    + stub_sec->output_offset);
15356             val -= (htab->glink_eh_frame->output_section->vma
15357                     + htab->glink_eh_frame->output_offset
15358                     + (p - htab->glink_eh_frame->contents));
15359             if (val + 0x80000000 > 0xffffffff)
15360               {
15361                 info->callbacks->einfo
15362                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15363                    stub_sec->name);
15364                 return FALSE;
15365               }
15366             bfd_put_32 (dynobj, val, p);
15367             p += 4;
15368             /* stub section size.  */
15369             p += 4;
15370             /* Augmentation.  */
15371             p += 1;
15372             /* Pad.  */
15373             p += 7;
15374           }
15375       if (htab->glink != NULL && htab->glink->size != 0)
15376         {
15377           /* FDE length.  */
15378           p += 4;
15379           /* CIE pointer.  */
15380           p += 4;
15381           /* Offset to .glink.  */
15382           val = (htab->glink->output_section->vma
15383                  + htab->glink->output_offset
15384                  + 8);
15385           val -= (htab->glink_eh_frame->output_section->vma
15386                   + htab->glink_eh_frame->output_offset
15387                   + (p - htab->glink_eh_frame->contents));
15388           if (val + 0x80000000 > 0xffffffff)
15389             {
15390               info->callbacks->einfo
15391                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15392                  htab->glink->name);
15393               return FALSE;
15394             }
15395           bfd_put_32 (dynobj, val, p);
15396           p += 4;
15397           /* .glink size.  */
15398           p += 4;
15399           /* Augmentation.  */
15400           p += 1;
15401           /* Ops.  */
15402           p += 7;
15403         }
15404
15405       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15406           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15407                                                htab->glink_eh_frame,
15408                                                htab->glink_eh_frame->contents))
15409         return FALSE;
15410     }
15411
15412   /* We need to handle writing out multiple GOT sections ourselves,
15413      since we didn't add them to DYNOBJ.  We know dynobj is the first
15414      bfd.  */
15415   while ((dynobj = dynobj->link.next) != NULL)
15416     {
15417       asection *s;
15418
15419       if (!is_ppc64_elf (dynobj))
15420         continue;
15421
15422       s = ppc64_elf_tdata (dynobj)->got;
15423       if (s != NULL
15424           && s->size != 0
15425           && s->output_section != bfd_abs_section_ptr
15426           && !bfd_set_section_contents (output_bfd, s->output_section,
15427                                         s->contents, s->output_offset,
15428                                         s->size))
15429         return FALSE;
15430       s = ppc64_elf_tdata (dynobj)->relgot;
15431       if (s != NULL
15432           && s->size != 0
15433           && s->output_section != bfd_abs_section_ptr
15434           && !bfd_set_section_contents (output_bfd, s->output_section,
15435                                         s->contents, s->output_offset,
15436                                         s->size))
15437         return FALSE;
15438     }
15439
15440   return TRUE;
15441 }
15442
15443 #include "elf64-target.h"
15444
15445 /* FreeBSD support */
15446
15447 #undef  TARGET_LITTLE_SYM
15448 #undef  TARGET_LITTLE_NAME
15449
15450 #undef  TARGET_BIG_SYM
15451 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15452 #undef  TARGET_BIG_NAME
15453 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15454
15455 #undef  ELF_OSABI
15456 #define ELF_OSABI       ELFOSABI_FREEBSD
15457
15458 #undef  elf64_bed
15459 #define elf64_bed       elf64_powerpc_fbsd_bed
15460
15461 #include "elf64-target.h"
15462